Merge from vscode 073a24de05773f2261f89172987002dc0ae2f1cd (#9711)

src/vs/base/common/buffer.ts

@@ -115,6 +115,19 @@ export class VSBuffer {
 	}
 }
 
+export function readUInt16LE(source: Uint8Array, offset: number): number {
+	return (
+		source[offset]
+		+ source[offset + 1] * 2 ** 8
+	);
+}
+
+export function writeUInt16LE(destination: Uint8Array, value: number, offset: number): void {
+	destination[offset] = value;
+	value = value >>> 8;
+	destination[offset + 1] = value;
+}
+
 export function readUInt32BE(source: Uint8Array, offset: number): number {
 	return (
 		source[offset] * 2 ** 24
@@ -134,11 +147,11 @@ export function writeUInt32BE(destination: Uint8Array, value: number, offset: nu
 	destination[offset] = value;
 }
 
-function readUInt8(source: Uint8Array, offset: number): number {
+export function readUInt8(source: Uint8Array, offset: number): number {
 	return source[offset];
 }
 
-function writeUInt8(destination: Uint8Array, value: number, offset: number): void {
+export function writeUInt8(destination: Uint8Array, value: number, offset: number): void {
 	destination[offset] = value;
 }
 

src/vs/base/common/fuzzyScorer.ts

@@ -321,6 +321,8 @@ export function prepareQuery(original: string): IPreparedQuery {
 	let value = stripWildcards(original).replace(/\s/g, ''); // get rid of all wildcards and whitespace
 	if (isWindows) {
 		value = value.replace(/\//g, sep); // Help Windows users to search for paths when using slash
+	} else {
+		value = value.replace(/\\/g, sep); // Help macOS/Linux users to search for paths when using backslash
 	}
 
 	const lowercase = value.toLowerCase();
@@ -451,7 +453,7 @@ function doScoreItem(label: string, description: string | undefined, path: strin
 	return NO_ITEM_SCORE;
 }
 
-export function compareItemsByScore<T>(itemA: T, itemB: T, query: IPreparedQuery, fuzzy: boolean, accessor: IItemAccessor<T>, cache: ScorerCache, fallbackComparer = fallbackCompare): number {
+export function compareItemsByScore<T>(itemA: T, itemB: T, query: IPreparedQuery, fuzzy: boolean, accessor: IItemAccessor<T>, cache: ScorerCache): number {
 	const itemScoreA = scoreItem(itemA, query, fuzzy, accessor, cache);
 	const itemScoreB = scoreItem(itemB, query, fuzzy, accessor, cache);
 
@@ -517,7 +519,16 @@ export function compareItemsByScore<T>(itemA: T, itemB: T, query: IPreparedQuery
 		return scoreA > scoreB ? -1 : 1;
 	}
 
-	// 6.) scores are identical, prefer more compact matches (label and description)
+	// 6.) prefer matches in label over non-label matches
+	const itemAHasLabelMatches = Array.isArray(itemScoreA.labelMatch) && itemScoreA.labelMatch.length > 0;
+	const itemBHasLabelMatches = Array.isArray(itemScoreB.labelMatch) && itemScoreB.labelMatch.length > 0;
+	if (itemAHasLabelMatches && !itemBHasLabelMatches) {
+		return -1;
+	} else if (itemBHasLabelMatches && !itemAHasLabelMatches) {
+		return 1;
+	}
+
+	// 7.) scores are identical, prefer more compact matches (label and description)
 	const itemAMatchDistance = computeLabelAndDescriptionMatchDistance(itemA, itemScoreA, accessor);
 	const itemBMatchDistance = computeLabelAndDescriptionMatchDistance(itemB, itemScoreB, accessor);
 	if (itemAMatchDistance && itemBMatchDistance && itemAMatchDistance !== itemBMatchDistance) {
@@ -526,7 +537,7 @@ export function compareItemsByScore<T>(itemA: T, itemB: T, query: IPreparedQuery
 
 	// 7.) at this point, scores are identical and match compactness as well
 	// for both items so we start to use the fallback compare
-	return fallbackComparer(itemA, itemB, query, accessor);
+	return fallbackCompare(itemA, itemB, query, accessor);
 }
 
 function computeLabelAndDescriptionMatchDistance<T>(item: T, score: IItemScore, accessor: IItemAccessor<T>): number {

src/vs/base/common/network.ts

@@ -53,6 +53,12 @@ export namespace Schemas {
 	export const vscodeRemoteResource = 'vscode-remote-resource';
 
 	export const userData = 'vscode-userdata';
+
+	export const vscodeCustomEditor = 'vscode-custom-editor';
+
+	export const vscodeSettings = 'vscode-settings';
+
+	export const webviewPanel = 'webview-panel';
 }
 
 class RemoteAuthoritiesImpl {

src/vs/base/common/platform.ts

@@ -209,3 +209,17 @@ export const enum OperatingSystem {
 	Linux = 3
 }
 export const OS = (_isMacintosh ? OperatingSystem.Macintosh : (_isWindows ? OperatingSystem.Windows : OperatingSystem.Linux));
+
+let _isLittleEndian = true;
+let _isLittleEndianComputed = false;
+export function isLittleEndian(): boolean {
+	if (!_isLittleEndianComputed) {
+		_isLittleEndianComputed = true;
+		const test = new Uint8Array(2);
+		test[0] = 1;
+		test[1] = 2;
+		const view = new Uint16Array(test.buffer);
+		_isLittleEndian = (view[0] === (2 << 8) + 1);
+	}
+	return _isLittleEndian;
+}

src/vs/base/common/resources.ts

@@ -15,8 +15,16 @@ import { TernarySearchTree } from 'vs/base/common/map';
 
 export const originalFSPath = uriOriginalFSPath;
 
-export function getComparisonKey(resource: URI): string {
-	return hasToIgnoreCase(resource) ? resource.toString().toLowerCase() : resource.toString();
+/**
+ * Creates a key from a resource URI to be used to resource comparison and for resource maps.
+ * URI queries are included, fragments are ignored.
+ */
+export function getComparisonKey(resource: URI, caseInsensitivePath = hasToIgnoreCase(resource)): string {
+	let path = resource.path || '/';
+	if (caseInsensitivePath) {
+		path = path.toLowerCase();
+	}
+	return `${resource.scheme}://${resource.authority.toLowerCase()}/${path}?${resource.query}`;
 }
 
 export function hasToIgnoreCase(resource: URI | undefined): boolean {
@@ -31,29 +39,33 @@ export function basenameOrAuthority(resource: URI): string {
 
 /**
  * Tests whether a `candidate` URI is a parent or equal of a given `base` URI.
+ * URI queries must match, fragments are ignored.
  * @param base A uri which is "longer"
  * @param parentCandidate A uri which is "shorter" then `base`
  */
 export function isEqualOrParent(base: URI, parentCandidate: URI, ignoreCase = hasToIgnoreCase(base)): boolean {
 	if (base.scheme === parentCandidate.scheme) {
 		if (base.scheme === Schemas.file) {
-			return extpath.isEqualOrParent(originalFSPath(base), originalFSPath(parentCandidate), ignoreCase);
+			return extpath.isEqualOrParent(originalFSPath(base), originalFSPath(parentCandidate), ignoreCase) && base.query === parentCandidate.query;
 		}
 		if (isEqualAuthority(base.authority, parentCandidate.authority)) {
-			return extpath.isEqualOrParent(base.path, parentCandidate.path, ignoreCase, '/');
+			return extpath.isEqualOrParent(base.path || '/', parentCandidate.path || '/', ignoreCase, '/') && base.query === parentCandidate.query;
 		}
 	}
 	return false;
 }
 
 /**
- * Tests wheter the two authorities are the same
+ * Tests whether the two authorities are the same
  */
 export function isEqualAuthority(a1: string, a2: string) {
 	return a1 === a2 || equalsIgnoreCase(a1, a2);
 }
 
-export function isEqual(first: URI | undefined, second: URI | undefined, ignoreCase = hasToIgnoreCase(first)): boolean {
+/**
+ * Tests whether two resources are the same.  URI queries must match, fragments are ignored unless requested.
+ */
+export function isEqual(first: URI | undefined, second: URI | undefined, caseInsensitivePath = hasToIgnoreCase(first), ignoreFragment = true): boolean {
 	if (first === second) {
 		return true;
 	}
@@ -67,7 +79,7 @@ export function isEqual(first: URI | undefined, second: URI | undefined, ignoreC
 	}
 
 	const p1 = first.path || '/', p2 = second.path || '/';
-	return p1 === p2 || ignoreCase && equalsIgnoreCase(p1 || '/', p2 || '/');
+	return (p1 === p2 || caseInsensitivePath && equalsIgnoreCase(p1, p2)) && first.query === second.query && (ignoreFragment || first.fragment === second.fragment);
 }
 
 export function basename(resource: URI): string {
@@ -88,13 +100,15 @@ export function dirname(resource: URI): URI {
 	if (resource.path.length === 0) {
 		return resource;
 	}
+	let dirname;
 	if (resource.scheme === Schemas.file) {
-		return URI.file(paths.dirname(originalFSPath(resource)));
-	}
-	let dirname = paths.posix.dirname(resource.path);
-	if (resource.authority && dirname.length && dirname.charCodeAt(0) !== CharCode.Slash) {
-		console.error(`dirname("${resource.toString})) resulted in a relative path`);
-		dirname = '/'; // If a URI contains an authority component, then the path component must either be empty or begin with a CharCode.Slash ("/") character
+		dirname = URI.file(paths.dirname(originalFSPath(resource))).path;
+	} else {
+		dirname = paths.posix.dirname(resource.path);
+		if (resource.authority && dirname.length && dirname.charCodeAt(0) !== CharCode.Slash) {
+			console.error(`dirname("${resource.toString})) resulted in a relative path`);
+			dirname = '/'; // If a URI contains an authority component, then the path component must either be empty or begin with a CharCode.Slash ("/") character
+		}
 	}
 	return resource.with({
 		path: dirname
@@ -189,7 +203,7 @@ export function addTrailingPathSeparator(resource: URI, sep: string = paths.sep)
  * Returns a relative path between two URIs. If the URIs don't have the same schema or authority, `undefined` is returned.
  * The returned relative path always uses forward slashes.
  */
-export function relativePath(from: URI, to: URI, ignoreCase = hasToIgnoreCase(from)): string | undefined {
+export function relativePath(from: URI, to: URI, caseInsensitivePath = hasToIgnoreCase(from)): string | undefined {
 	if (from.scheme !== to.scheme || !isEqualAuthority(from.authority, to.authority)) {
 		return undefined;
 	}
@@ -198,7 +212,7 @@ export function relativePath(from: URI, to: URI, ignoreCase = hasToIgnoreCase(fr
 		return isWindows ? extpath.toSlashes(relativePath) : relativePath;
 	}
 	let fromPath = from.path || '/', toPath = to.path || '/';
-	if (ignoreCase) {
+	if (caseInsensitivePath) {
 		// make casing of fromPath match toPath
 		let i = 0;
 		for (const len = Math.min(fromPath.length, toPath.length); i < len; i++) {