Strongly type file paths

packages/typescript/package.json

@@ -50,6 +50,10 @@
             "@typescript/source": "./src/api/fs.ts",
             "default": "./dist/api/fs.js"
         },
+        "./unstable/path": {
+            "@typescript/source": "./src/api/typedPaths.ts",
+            "default": "./dist/api/typedPaths.js"
+        },
         "./unstable/proto": {
             "@typescript/source": "./src/api/proto.ts",
             "default": "./dist/api/proto.js"

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

@@ -9,6 +9,11 @@ import {
 } from "#vscode-jsonrpc/node";
 import type { ChildProcess } from "node:child_process";
 import type { Socket } from "node:net";
+import type {
+    RootedDirectoryPath,
+    RootedFilePath,
+    RootedPath,
+} from "../../ast/index.ts";
 import {
     type FileSystem,
     fsCallbackNames,
@@ -141,32 +146,45 @@ export class Client {
     private registerFSCallbacks(connection: MessageConnection, fs: FileSystem | undefined): void {
         if (!fs) return;
         for (const name of fsCallbackNames) {
-            if (name === "writeFile") {
-                if (!fs.writeFile) continue;
-                const callback = fs.writeFile;
-
-                const requestType = new RequestType<{ path: string; data: string; }, unknown, void>(name);
-                connection.onRequest(requestType, (arg: { path: string; data: string; }) => {
-                    callback(arg.path, arg.data);
-                    return null;
-                });
-
-                continue;
-            }
-
-            const callback = fs[name];
-            if (callback) {
-                const requestType = new RequestType<unknown, unknown, void>(name);
-                connection.onRequest(requestType, (arg: unknown) => {
-                    const result = callback(arg as any);
-                    if (name === "readFile") {
-                        // readFile has 3 returns: string (content), null (not found), undefined (fall back).
-                        // JSON-RPC can't distinguish null from undefined, so wrap in object.
-                        if (result === undefined) return null;
-                        return { content: result };
+            switch (name) {
+                case "readFile":
+                    if (fs.readFile) {
+                        connection.onRequest(new RequestType<RootedFilePath, unknown, void>(name), fileName => {
+                            const result = fs.readFile!(fileName);
+                            // readFile has 3 returns: string (content), null (not found), undefined (fall back).
+                            // JSON-RPC can't distinguish null from undefined, so wrap in object.
+                            return result === undefined ? null : { content: result };
+                        });
+                    }
+                    break;
+                case "fileExists":
+                    if (fs.fileExists) {
+                        connection.onRequest(new RequestType<RootedFilePath, unknown, void>(name), fileName => fs.fileExists!(fileName) ?? null);
+                    }
+                    break;
+                case "directoryExists":
+                    if (fs.directoryExists) {
+                        connection.onRequest(new RequestType<RootedDirectoryPath, unknown, void>(name), directoryName => fs.directoryExists!(directoryName) ?? null);
+                    }
+                    break;
+                case "getAccessibleEntries":
+                    if (fs.getAccessibleEntries) {
+                        connection.onRequest(new RequestType<RootedDirectoryPath, unknown, void>(name), directoryName => fs.getAccessibleEntries!(directoryName) ?? null);
+                    }
+                    break;
+                case "realpath":
+                    if (fs.realpath) {
+                        connection.onRequest(new RequestType<RootedPath, unknown, void>(name), path => fs.realpath!(path) ?? null);
+                    }
+                    break;
+                case "writeFile":
+                    if (fs.writeFile) {
+                        connection.onRequest(new RequestType<{ path: RootedFilePath; data: string; }, unknown, void>(name), arg => {
+                            fs.writeFile!(arg.path, arg.data);
+                            return null;
+                        });
                     }
-                    return result ?? null;
-                });
+                    break;
             }
         }
     }

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

@@ -8,6 +8,10 @@ import type {
     NamedTupleMember,
     ParameterDeclaration,
 } from "../../ast/ast.ts";
+import type {
+    RootedDirectoryPath,
+    RootedFilePath,
+} from "../../ast/index.ts";
 import type {
     Diagnostic,
     RequestFileSystem,
@@ -410,28 +414,28 @@ export interface CompletionInfo {
 }
 
 export interface FormatDiagnosticsHost {
-    getCurrentDirectory(): string;
+    getCurrentDirectory(): RootedDirectoryPath;
     getCanonicalFileName(fileName: string): string;
     getNewLine(): string;
 }
 
 export interface EmitOutputFile {
     readonly text: string;
-    readonly sourceFileName?: string | undefined;
+    readonly sourceFileName?: RootedFilePath | undefined;
 }
 
 export interface EmitResult {
     readonly emitSkipped: boolean;
     readonly diagnostics: readonly Diagnostic[];
-    readonly emittedFiles: readonly string[];
+    readonly emittedFiles: readonly RootedFilePath[];
     /** Emitted files captured as a filesystem layer suitable for {@link Snapshot.update}. */
     readonly fileSystem?: RequestFileSystem | undefined;
 }
 
 export interface EmitOutput {
     readonly emitSkipped: boolean;
     readonly diagnostics: readonly Diagnostic[];
-    readonly outputFiles: ReadonlyMap<string, EmitOutputFile>;
+    readonly outputFiles: ReadonlyMap<RootedFilePath, EmitOutputFile>;
 }
 
 export interface ImportSymbolAction {

packages/typescript/src/api/diagnosticFormatter.ts

@@ -1,8 +1,12 @@
+import type {
+    RootedDirectoryPath,
+    RootedFilePath,
+} from "../ast/index.ts";
 import { convertToRelativePath } from "./path.ts";
 import type { DiagnosticResponse as Diagnostic } from "./proto.generated.ts";
 
 export interface FormatDiagnosticsHost {
-    getCurrentDirectory(): string;
+    getCurrentDirectory(): RootedDirectoryPath;
     getCanonicalFileName(fileName: string): string;
     getNewLine(): string;
 }
@@ -70,7 +74,7 @@ function flattenDiagnosticMessage(diagnostic: Diagnostic, newLine: string, inden
     return result;
 }
 
-function relativeFileName(fileName: string, host: FormatDiagnosticsHost): string {
+function relativeFileName(fileName: RootedFilePath, host: FormatDiagnosticsHost): string {
     return convertToRelativePath(
         fileName,
         host.getCurrentDirectory(),