Typed path prep bugfixes (#64544)

Author: jakebailey

packages/typescript/src/api/async/api.ts

@@ -340,7 +340,7 @@ export class API<FromLSP extends boolean = false> implements FormatDiagnosticsHo
     readonly client: Client;
     /** @internal */
     readonly sourceFileCache: SourceFileCache<Symbol>;
-    private toPath: ((fileName: string) => Path) | undefined;
+    private toPath: ((fileName: string, basePath?: string) => Path) | undefined;
     private currentDirectory: string | undefined;
     private readonly decoder = new Wtf8Decoder();
     private getCanonicalFileNameWorker: ((fileName: string) => string) | undefined;
@@ -442,7 +442,7 @@ export class API<FromLSP extends boolean = false> implements FormatDiagnosticsHo
             const currentDirectory = response.currentDirectory;
             this.getCanonicalFileNameWorker = getCanonicalFileName;
             this.currentDirectory = currentDirectory;
-            this.toPath = (fileName: string) => toPath(fileName, currentDirectory, getCanonicalFileName) as Path;
+            this.toPath = (fileName: string, basePath = currentDirectory) => toPath(fileName, basePath, getCanonicalFileName) as Path;
             this.initialized = true;
         }
         catch (error) {
@@ -1023,7 +1023,7 @@ export class Snapshot {
     readonly id: number;
     readonly operation: SnapshotOperation;
     private projectMap: Map<ProjectId, Project>;
-    private toPath: (fileName: string) => Path;
+    private toPath: (fileName: string, basePath?: string) => Path;
     private readonly api: API<boolean>;
     private disposed: boolean = false;
     private disposePromise: Promise<void> | undefined;
@@ -1037,7 +1037,7 @@ export class Snapshot {
         return this.api.client;
     }
 
-    constructor(data: CreateSnapshotResponse, toPath: (fileName: string) => Path, api: API<boolean>, onDispose: () => void, updateSnapshot: SnapshotUpdater, baseSnapshot?: Snapshot) {
+    constructor(data: CreateSnapshotResponse, toPath: (fileName: string, basePath?: string) => Path, api: API<boolean>, onDispose: () => void, updateSnapshot: SnapshotUpdater, baseSnapshot?: Snapshot) {
         this.id = data.snapshot;
         this.api = api;
         this.toPath = toPath;
@@ -1527,7 +1527,7 @@ export class Project<Id extends ProjectId = ProjectId> {
     readonly languageService: LanguageService;
     private snapshotId: number;
 
-    constructor(data: ProjectResponse, snapshotId: number, toPath: (fileName: string) => Path, api: API<boolean>, snapshotRegistry: SnapshotObjectRegistry) {
+    constructor(data: ProjectResponse, snapshotId: number, toPath: (fileName: string, basePath?: string) => Path, api: API<boolean>, snapshotRegistry: SnapshotObjectRegistry) {
         this.id = data.id as Id;
         this.api = api;
         this.configFileName = data.configFileName;
@@ -1672,7 +1672,7 @@ export class Program<Id extends ProjectId = ProjectId> implements FormatDiagnost
     readonly snapshotId: number;
     readonly id: Id;
     private readonly project: Project<Id>;
-    private readonly toPath: (fileName: string) => Path;
+    private readonly toPath: (fileName: string, basePath?: string) => Path;
     private readonly decoder = new Wtf8Decoder();
     private readonly sourceFileMetadataCache = new Map<Path, Promise<SourceFileMetadata | undefined>>();
     private ownedSnapshot: Snapshot | undefined;
@@ -1686,7 +1686,7 @@ export class Program<Id extends ProjectId = ProjectId> implements FormatDiagnost
         return this.project.api.sourceFileCache;
     }
 
-    constructor(snapshotId: number, project: Project<Id>, toPath: (fileName: string) => Path) {
+    constructor(snapshotId: number, project: Project<Id>, toPath: (fileName: string, basePath?: string) => Path) {
         this.snapshotId = snapshotId;
         this.id = project.id;
         this.project = project;
@@ -1730,7 +1730,7 @@ export class Program<Id extends ProjectId = ProjectId> implements FormatDiagnost
 
     async getSourceFile(file: DocumentIdentifier): Promise<SourceFile | undefined> {
         const fileName = resolveFileName(file);
-        const path = this.toPath(fileName);
+        const path = this.toPath(fileName, this.project.currentDirectory);
 
         // Check if we already have a retained cache entry for this (snapshot, project) pair
         const retained = this.sourceFileCache.getRetained(path, this.snapshotId, this.project.id);
@@ -1842,7 +1842,7 @@ export class Program<Id extends ProjectId = ProjectId> implements FormatDiagnost
      * `Program` instance.
      */
     getSourceFileMetadata(file: DocumentIdentifier): Promise<SourceFileMetadata | undefined> {
-        return this.getSourceFileMetadataByPath(this.toPath(resolveFileName(file)));
+        return this.getSourceFileMetadataByPath(this.toPath(resolveFileName(file), this.project.currentDirectory));
     }
 
     /**

packages/typescript/src/api/path.ts

@@ -88,6 +88,18 @@ function getEncodedRootLength(path: string): number {
         return p1 + 1; // UNC: "//server/" or "\\server\"
     }
 
+    // Dynamic/virtual compiler file name.
+    if (ch0 === 94 /* ^ */ && path.charCodeAt(1) === CharacterCodesSlash) {
+        if (path.startsWith(dynamicURIFileNamePrefix)) {
+            const schemeEnd = path.indexOf(directorySeparator, dynamicURIFileNamePrefix.length);
+            if (schemeEnd !== -1) {
+                const authorityEnd = path.indexOf(directorySeparator, schemeEnd + 1);
+                return authorityEnd === -1 ? path.length : authorityEnd + 1;
+            }
+        }
+        return 2;
+    }
+
     // DOS
     if (isVolumeCharacter(ch0) && path.charCodeAt(1) === CharacterCodesColon) {
         const ch2 = path.charCodeAt(2);
@@ -109,7 +121,7 @@ function getEncodedRootLength(path: string): number {
             const scheme = path.slice(0, schemeEnd);
             const authority = path.slice(authorityStart, authorityEnd);
             if (
-                scheme === "file" && (authority === "" || authority === "localhost") &&
+                scheme.toLowerCase() === "file" && (authority === "" || authority.toLowerCase() === "localhost") &&
                 isVolumeCharacter(path.charCodeAt(authorityEnd + 1))
             ) {
                 const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
@@ -391,7 +403,9 @@ export function toPath(fileName: string, basePath: string | undefined, getCanoni
     const nonCanonicalizedPath = isRootedDiskPath(fileName)
         ? normalizePath(fileName)
         : getNormalizedAbsolutePath(fileName, basePath);
-    return getCanonicalFileName(nonCanonicalizedPath);
+    return nonCanonicalizedPath.startsWith(dynamicURIFileNamePrefix)
+        ? nonCanonicalizedPath
+        : getCanonicalFileName(nonCanonicalizedPath);
 }
 
 /**
@@ -410,6 +424,11 @@ function toLowerCase(s: string): string {
 }
 
 const bundledScheme = "bundled:///";
+const dynamicURIFileNamePrefix = "^/~ts-uri~/";
+const dynamicURIPathSegmentEscapePrefix = "~ts-uri-escape~";
+const dynamicURIModuleSpecifierEscapePrefix = "~ts-uri-spec~";
+const dynamicURINoPathEscapePrefix = "~ts-uri-no-path~";
+const dynamicURIPathSegmentEscapeRegExp = /(?:^|\/)(?:\.{1,2}(?:\/|$)|~ts-uri-escape~|~ts-uri-spec~|~ts-uri-no-path~)/;
 
 /**
  * Returns true if the path refers to a bundled library file.
@@ -493,8 +512,8 @@ export function fileNameToDocumentURI(fileName: string): string {
 
     // Dynamic/virtual files (untitled, vscode-vfs, etc.) need special handling
     if (isDynamicFileName(fileName)) {
-        // Format: ^/scheme/authority/path
-        const withoutPrefix = fileName.substring(2); // Remove "^/"
+        const encoded = fileName.startsWith(dynamicURIFileNamePrefix);
+        const withoutPrefix = fileName.substring(encoded ? dynamicURIFileNamePrefix.length : 2);
         const firstSlash = withoutPrefix.indexOf("/");
         if (firstSlash === -1) {
             throw new Error("invalid file name: " + fileName);
@@ -506,11 +525,20 @@ export function fileNameToDocumentURI(fileName: string): string {
         if (secondSlash === -1) {
             throw new Error("invalid file name: " + fileName);
         }
-        const authority = rest.substring(0, secondSlash);
-        const path = rest.substring(secondSlash + 1);
+        const encodedAuthority = rest.substring(0, secondSlash);
+        const hasAuthority = encodedAuthority !== "ts-nul-authority";
+        const authority = encoded ? decodeDynamicURIPathSegment(encodedAuthority) : encodedAuthority;
+        const encodedPath = rest.substring(secondSlash + 1);
+        if (encoded && hasAuthority) {
+            const suffix = decodeDynamicURINoPath(encodedPath);
+            if (suffix !== undefined) {
+                return scheme + "://" + authority + suffix;
+            }
+        }
+        const path = encoded ? decodeDynamicURIPath(encodedPath) : encodedPath;
 
         // ts-nul-authority is a placeholder for URIs without an authority
-        if (authority === "ts-nul-authority") {
+        if (!hasAuthority) {
             return scheme + ":" + path;
         }
         return scheme + "://" + authority + "/" + path;
@@ -585,17 +613,188 @@ export function documentURIToFileName(uri: string): string {
 
     const scheme = uri.substring(0, colonIndex);
     let path = uri.substring(colonIndex + 1);
+    let suffix = "";
+    const suffixStart = path.search(/[?#]/);
+    if (suffixStart !== -1) {
+        suffix = path.substring(suffixStart);
+        path = path.substring(0, suffixStart);
+    }
 
     let authority = "ts-nul-authority";
+    let hasAuthority = false;
+    let hasPath = true;
     if (path.startsWith("//")) {
+        hasAuthority = true;
         const rest = path.substring(2);
         const slashIndex = rest.indexOf("/");
         if (slashIndex === -1) {
-            throw new Error("invalid URI: " + uri);
+            authority = rest;
+            path = "";
+            hasPath = false;
+        }
+        else {
+            authority = rest.substring(0, slashIndex);
+            path = rest.substring(slashIndex + 1);
+        }
+    }
+
+    let encodedAuthority = authority;
+    if (hasAuthority) {
+        encodedAuthority = authority === "ts-nul-authority"
+            ? forceEncodeDynamicURIPathSegment(authority, false)
+            : encodeDynamicURIPath(authority);
+    }
+    const encodedPath = hasPath
+        ? encodeDynamicURIPathWithSuffix(path, suffix)
+        : encodeDynamicURINoPath(suffix);
+    return dynamicURIFileNamePrefix + scheme + "/" + encodedAuthority + "/" + encodedPath;
+}
+
+function encodeDynamicURIPath(path: string, preserveFinalExtension = true): string {
+    if (!dynamicURIPathNeedsEncoding(path) && !isRootedDiskPath(path)) {
+        return path;
+    }
+    const segments = path.split("/");
+    for (let i = 0; i < segments.length; i++) {
+        segments[i] = encodeDynamicURIPathSegment(segments[i], preserveFinalExtension && i === segments.length - 1);
+    }
+    if (isRootedDiskPath(segments.join("/"))) {
+        segments[0] = forceEncodeDynamicURIPathSegment(segments[0], segments.length === 1 && preserveFinalExtension);
+    }
+    return segments.join("/");
+}
+
+function encodeDynamicURIPathWithSuffix(path: string, suffix: string): string {
+    if (suffix === "") {
+        return encodeDynamicURIPath(path);
+    }
+    const slash = path.lastIndexOf("/");
+    const before = slash === -1 ? "" : encodeDynamicURIPath(path.substring(0, slash), false) + "/";
+    return before + forceEncodeDynamicURIPathSegmentWithSuffix(path.substring(slash + 1), suffix);
+}
+
+function dynamicURIPathNeedsEncoding(path: string): boolean {
+    return path === "" ||
+        path.startsWith("/") ||
+        path.endsWith("/") ||
+        path.includes("//") ||
+        path.includes("\\") ||
+        dynamicURIPathSegmentEscapeRegExp.test(path);
+}
+
+function dynamicURIPathSegmentNeedsEncoding(segment: string): boolean {
+    return segment === "" ||
+        segment === "." ||
+        segment === ".." ||
+        segment.startsWith(dynamicURIPathSegmentEscapePrefix) ||
+        segment.startsWith(dynamicURIModuleSpecifierEscapePrefix) ||
+        segment.startsWith(dynamicURINoPathEscapePrefix) ||
+        segment.includes("\\");
+}
+
+function encodeDynamicURIPathSegment(segment: string, preserveExtension: boolean): string {
+    return dynamicURIPathSegmentNeedsEncoding(segment)
+        ? forceEncodeDynamicURIPathSegment(segment, preserveExtension)
+        : segment;
+}
+
+function forceEncodeDynamicURIPathSegment(segment: string, preserveExtension: boolean): string {
+    let extension = "";
+    if (preserveExtension && segment !== "." && segment !== "..") {
+        [segment, extension] = splitDynamicURIFileExtension(segment);
+    }
+    return dynamicURIPathSegmentEscapePrefix + encodeDynamicURIHex(segment) + "~" + extension;
+}
+
+function forceEncodeDynamicURIPathSegmentWithSuffix(segment: string, suffix: string): string {
+    const [base, extension] = splitDynamicURIFileExtension(segment);
+    return forceEncodeDynamicURIPathSegment(base + "\0" + suffix, false) + extension;
+}
+
+function splitDynamicURIFileExtension(segment: string): [base: string, extension: string] {
+    const extension = getDynamicURIFileExtension(segment);
+    return extension === ""
+        ? [segment, extension]
+        : [segment.substring(0, segment.length - extension.length), extension];
+}
+
+function getDynamicURIFileExtension(segment: string): string {
+    const baseStart = segment.lastIndexOf("\\") + 1;
+    for (const extension of [".d.ts", ".d.mts", ".d.cts"]) {
+        if (segment.endsWith(extension) && segment.length - extension.length >= baseStart) {
+            return extension;
+        }
+    }
+    if (segment.endsWith(".ts")) {
+        const declaration = segment.indexOf(".d.", baseStart);
+        if (declaration !== -1) {
+            return segment.substring(declaration);
         }
-        authority = rest.substring(0, slashIndex);
-        path = rest.substring(slashIndex + 1);
     }
+    const dot = segment.lastIndexOf(".");
+    return dot >= baseStart ? segment.substring(dot) : "";
+}
+
+function encodeDynamicURIHex(text: string): string {
+    let hex = "";
+    const encoded = encodeURIComponent(text);
+    for (let i = 0; i < encoded.length; i++) {
+        if (encoded.charCodeAt(i) === CharacterCodesPercent) {
+            hex += encoded.slice(i + 1, i + 3).toLowerCase();
+            i += 2;
+        }
+        else {
+            hex += encoded.charCodeAt(i).toString(16).padStart(2, "0");
+        }
+    }
+    return hex;
+}
 
-    return "^/" + scheme + "/" + authority + "/" + path;
+function decodeDynamicURIPath(path: string): string {
+    return path.includes(dynamicURIPathSegmentEscapePrefix)
+        ? path.split("/").map(decodeDynamicURIPathSegment).join("/")
+        : path;
+}
+
+function decodeDynamicURIPathSegment(segment: string): string {
+    if (!segment.startsWith(dynamicURIPathSegmentEscapePrefix)) {
+        return segment;
+    }
+    const separator = segment.indexOf("~", dynamicURIPathSegmentEscapePrefix.length);
+    if (separator === -1) {
+        return segment;
+    }
+    const encoded = segment.slice(dynamicURIPathSegmentEscapePrefix.length, separator);
+    const extension = segment.slice(separator + 1);
+    const decoded = decodeDynamicURIHex(encoded);
+    if (decoded === undefined) {
+        return segment;
+    }
+    const suffix = decoded.indexOf("\0");
+    return suffix === -1
+        ? decoded + extension
+        : decoded.substring(0, suffix) + extension + decoded.substring(suffix + 1);
+}
+
+function encodeDynamicURINoPath(suffix: string): string {
+    return dynamicURINoPathEscapePrefix + encodeDynamicURIHex(suffix) + "~";
+}
+
+function decodeDynamicURINoPath(path: string): string | undefined {
+    if (!path.startsWith(dynamicURINoPathEscapePrefix) || !path.endsWith("~")) {
+        return undefined;
+    }
+    return decodeDynamicURIHex(path.substring(dynamicURINoPathEscapePrefix.length, path.length - 1));
+}
+
+function decodeDynamicURIHex(encoded: string): string | undefined {
+    if (encoded.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(encoded)) {
+        return undefined;
+    }
+    try {
+        return decodeURIComponent(encoded.replace(/../g, value => `%${value}`));
+    }
+    catch {
+        return undefined;
+    }
 }