More usage of NormalizedPath

Author: nojaf

client/src/commands/code_analysis.ts

@@ -14,7 +14,11 @@ import {
   OutputChannel,
   StatusBarItem,
 } from "vscode";
-import { findProjectRootOfFileInDir, getBinaryPath } from "../utils";
+import {
+  findProjectRootOfFileInDir,
+  getBinaryPath,
+  NormalizedPath,
+} from "../utils";
 
 export let statusBarItem = {
   setToStopText: (codeAnalysisRunningStatusBarItem: StatusBarItem) => {
@@ -208,7 +212,7 @@ export const runCodeAnalysisWithReanalyze = (
   let currentDocument = window.activeTextEditor.document;
   let cwd = targetDir ?? path.dirname(currentDocument.uri.fsPath);
 
-  let projectRootPath: string | null = findProjectRootOfFileInDir(
+  let projectRootPath: NormalizedPath | null = findProjectRootOfFileInDir(
     currentDocument.uri.fsPath,
   );
 

client/src/commands/dump_debug.ts

@@ -11,6 +11,7 @@ import {
   createFileInTempDir,
   findProjectRootOfFileInDir,
   getBinaryPath,
+  NormalizedPath,
 } from "../utils";
 import * as path from "path";
 
@@ -136,7 +137,8 @@ export const dumpDebug = async (
   const { line: endLine, character: endChar } = editor.selection.end;
   const filePath = editor.document.uri.fsPath;
 
-  let projectRootPath: string | null = findProjectRootOfFileInDir(filePath);
+  let projectRootPath: NormalizedPath | null =
+    findProjectRootOfFileInDir(filePath);
   const binaryPath = getBinaryPath(
     "rescript-editor-analysis.exe",
     projectRootPath,

client/src/utils.ts

@@ -9,6 +9,26 @@ import { DocumentUri } from "vscode-languageclient";
  * to the server itself.
  */
 
+/**
+ * Branded type for normalized file paths.
+ *
+ * All paths should be normalized to ensure consistent lookups and prevent
+ * path format mismatches (e.g., trailing slashes, relative vs absolute paths).
+ *
+ * Use `normalizePath()` to convert a regular path to a `NormalizedPath`.
+ */
+export type NormalizedPath = string & { __brand: "NormalizedPath" };
+
+/**
+ * Normalizes a file path and returns it as a `NormalizedPath`.
+ *
+ * @param filePath - The path to normalize (can be null)
+ * @returns The normalized path, or null if input was null
+ */
+export function normalizePath(filePath: string | null): NormalizedPath | null {
+  return filePath != null ? (path.normalize(filePath) as NormalizedPath) : null;
+}
+
 type binaryName = "rescript-editor-analysis.exe" | "rescript-tools.exe";
 
 const platformDir =
@@ -29,7 +49,7 @@ export const getLegacyBinaryProdPath = (b: binaryName) =>
 
 export const getBinaryPath = (
   binaryName: "rescript-editor-analysis.exe" | "rescript-tools.exe",
-  projectRootPath: string | null = null,
+  projectRootPath: NormalizedPath | null = null,
 ): string | null => {
   const binaryFromCompilerPackage = path.join(
     projectRootPath ?? "",
@@ -59,15 +79,24 @@ export const createFileInTempDir = (prefix = "", extension = "") => {
   return path.join(os.tmpdir(), tempFileName);
 };
 
-export let findProjectRootOfFileInDir = (source: string): null | string => {
-  let dir = path.dirname(source);
+export let findProjectRootOfFileInDir = (
+  source: string,
+): NormalizedPath | null => {
+  const normalizedSource = normalizePath(source);
+  if (normalizedSource == null) {
+    return null;
+  }
+  const dir = normalizePath(path.dirname(normalizedSource));
+  if (dir == null) {
+    return null;
+  }
   if (
     fs.existsSync(path.join(dir, "rescript.json")) ||
     fs.existsSync(path.join(dir, "bsconfig.json"))
   ) {
     return dir;
   } else {
-    if (dir === source) {
+    if (dir === normalizedSource) {
       // reached top
       return null;
     } else {

server/src/bsc-args/rewatch.ts

@@ -17,7 +17,7 @@ export type RewatchCompilerArgs = {
 
 async function getRuntimePath(
   entry: IncrementallyCompiledFileInfo,
-): Promise<string | null> {
+): Promise<utils.NormalizedPath | null> {
   return utils.getRuntimePathFromWorkspaceRoot(entry.project.workspaceRootPath);
 }
 
@@ -103,7 +103,8 @@ export async function getRewatchBscArgs(
         includePrerelease: true,
       })
     ) {
-      let rescriptRuntime: string | null = await getRuntimePath(entry);
+      let rescriptRuntime: utils.NormalizedPath | null =
+        await getRuntimePath(entry);
 
       if (rescriptRuntime !== null) {
         env["RESCRIPT_RUNTIME"] = rescriptRuntime;

server/src/codeActions.ts

@@ -7,7 +7,7 @@ import * as utils from "./utils";
 export type fileCodeActions = { range: p.Range; codeAction: p.CodeAction };
 
 export type filesCodeActions = {
-  [key: string]: fileCodeActions[];
+  [key: utils.FileURI]: fileCodeActions[];
 };
 
 interface findCodeActionsConfig {
@@ -326,7 +326,7 @@ let handleUndefinedRecordFieldsAction = ({
 }: {
   recordFieldNames: string[];
   codeActions: filesCodeActions;
-  file: string;
+  file: utils.FileURI;
   range: p.Range;
   diagnostic: p.Diagnostic;
   todoValue: string;

server/src/find-runtime.ts

@@ -1,6 +1,7 @@
 import { readdir, stat as statAsync, readFile } from "fs/promises";
 import { join, resolve } from "path";
 import { compilerInfoPartialPath } from "./constants";
+import { NormalizedPath } from "./utils";
 
 // Efficient parallel folder traversal to find node_modules directories
 async function findNodeModulesDirs(
@@ -92,14 +93,16 @@ async function findRescriptRuntimeInAlternativeLayout(
   return results;
 }
 
-async function findRuntimePath(project: string): Promise<string[]> {
+async function findRuntimePath(
+  project: NormalizedPath,
+): Promise<NormalizedPath[]> {
   // Try a compiler-info.json file first
   const compilerInfo = resolve(project, compilerInfoPartialPath);
   try {
     const contents = await readFile(compilerInfo, "utf8");
     const compileInfo: { runtime_path?: string } = JSON.parse(contents);
     if (compileInfo && compileInfo.runtime_path) {
-      return [compileInfo.runtime_path];
+      return [compileInfo.runtime_path as NormalizedPath];
     }
   } catch {
     // Ignore errors, fallback to node_modules search
@@ -146,12 +149,16 @@ async function findRuntimePath(project: string): Promise<string[]> {
     }),
   ).then((results) => results.flatMap((x) => x));
 
-  return rescriptRuntimeDirs.map((runtime) => resolve(runtime));
+  return rescriptRuntimeDirs.map(
+    (runtime) => resolve(runtime) as NormalizedPath,
+  );
 }
 
-function findRuntimeCached(): (project: string) => Promise<string[]> {
-  const cache = new Map<string, string[]>();
-  return async (project: string) => {
+function findRuntimeCached(): (
+  project: NormalizedPath,
+) => Promise<NormalizedPath[]> {
+  const cache = new Map<NormalizedPath, NormalizedPath[]>();
+  return async (project: NormalizedPath) => {
     if (cache.has(project)) {
       return cache.get(project)!;
     }

server/src/incrementalCompilation.ts

@@ -1,7 +1,6 @@
 import * as path from "path";
 import fs from "fs";
 import * as utils from "./utils";
-import readline from "readline";
 import { performance } from "perf_hooks";
 import * as p from "vscode-languageserver-protocol";
 import * as cp from "node:child_process";
@@ -41,9 +40,9 @@ export type IncrementallyCompiledFileInfo = {
     /** Namespaced module name of the source file. */
     moduleNameNamespaced: string;
     /** Path to where the incremental file is saved. */
-    incrementalFilePath: string;
+    incrementalFilePath: NormalizedPath;
     /** Location of the original type file. */
-    originalTypeFileLocation: string;
+    originalTypeFileLocation: NormalizedPath;
   };
   buildSystem: "bsb" | "rewatch";
   /** Cache for build.ninja assets. */
@@ -55,7 +54,7 @@ export type IncrementallyCompiledFileInfo = {
   } | null;
   /** Cache for rewatch compiler args. */
   buildRewatch: {
-    lastFile: string;
+    lastFile: NormalizedPath;
     compilerArgs: RewatchCompilerArgs;
   } | null;
   /** Info of the currently active incremental compilation. `null` if no incremental compilation is active. */
@@ -88,8 +87,9 @@ const incrementallyCompiledFileInfo: Map<
   NormalizedPath,
   IncrementallyCompiledFileInfo
 > = new Map();
-const hasReportedFeatureFailedError: Set<string> = new Set();
-const originalTypeFileToFilePath: Map<string, NormalizedPath> = new Map();
+const hasReportedFeatureFailedError: Set<NormalizedPath> = new Set();
+const originalTypeFileToFilePath: Map<NormalizedPath, NormalizedPath> =
+  new Map();
 
 export function incrementalCompilationFileChanged(changedPath: NormalizedPath) {
   const filePath = originalTypeFileToFilePath.get(changedPath);
@@ -311,12 +311,12 @@ function triggerIncrementalCompilationOfFile(
       projectRootPath,
       c.compilerDirPartialPath,
       path.relative(projectRootPath, filePath),
-    );
+    ) as NormalizedPath;
 
     const parsed = path.parse(originalTypeFileLocation);
     parsed.ext = ext === ".res" ? ".cmt" : ".cmti";
     parsed.base = "";
-    originalTypeFileLocation = path.format(parsed);
+    originalTypeFileLocation = path.format(parsed) as NormalizedPath;
 
     incrementalFileCacheEntry = {
       file: {
@@ -326,7 +326,10 @@ function triggerIncrementalCompilationOfFile(
         moduleNameNamespaced,
         sourceFileName: moduleName + ext,
         sourceFilePath: filePath,
-        incrementalFilePath: path.join(incrementalFolderPath, moduleName + ext),
+        incrementalFilePath: path.join(
+          incrementalFolderPath,
+          moduleName + ext,
+        ) as NormalizedPath,
       },
       project: {
         workspaceRootPath,

server/src/server.ts

@@ -27,10 +27,11 @@ import { onErrorReported } from "./errorReporter";
 import * as ic from "./incrementalCompilation";
 import config, { extensionConfiguration } from "./config";
 import { projectsFiles } from "./projectFiles";
+import { NormalizedPath } from "./utils";
 
 // Absolute paths to all the workspace folders
 // Configured during the initialize request
-export const workspaceFolders = new Set<string>();
+export const workspaceFolders = new Set<NormalizedPath>();
 
 // This holds client capabilities specific to our extension, and not necessarily
 // related to the LS protocol. It's for enabling/disabling features that might
@@ -75,7 +76,7 @@ const projectCompilationStates: Map<string, ProjectCompilationState> =
 
 type CompilationStatusPayload = {
   project: string;
-  projectRootPath: string;
+  projectRootPath: NormalizedPath;
   status: "compiling" | "success" | "error" | "warning";
   errorCount: number;
   warningCount: number;
@@ -921,7 +922,7 @@ async function codeAction(msg: p.RequestMessage): Promise<p.ResponseMessage> {
   // Check local code actions coming from the diagnostics, or from incremental compilation.
   let localResults: v.CodeAction[] = [];
   const fromDiagnostics =
-    codeActionsFromDiagnostics[params.textDocument.uri] ?? [];
+    codeActionsFromDiagnostics[params.textDocument.uri as utils.FileURI] ?? [];
   const fromIncrementalCompilation =
     ic.getCodeActionsFromIncrementalCompilation(filePath) ?? [];
   [...fromDiagnostics, ...fromIncrementalCompilation].forEach(

server/src/utils.ts

@@ -74,10 +74,10 @@ export function uriToNormalizedPath(uri: FileURI): NormalizedPath {
 let tempFilePrefix = "rescript_format_file_" + process.pid + "_";
 let tempFileId = 0;
 
-export let createFileInTempDir = (extension = "") => {
+export let createFileInTempDir = (extension = ""): NormalizedPath => {
   let tempFileName = tempFilePrefix + tempFileId + extension;
   tempFileId = tempFileId + 1;
-  return path.join(os.tmpdir(), tempFileName);
+  return path.join(os.tmpdir(), tempFileName) as NormalizedPath;
 };
 
 let findProjectRootOfFileInDir = (
@@ -501,23 +501,24 @@ export function computeWorkspaceRootPathFromLockfile(
 }
 
 // Shared cache: key is either workspace root path or project root path
-const runtimePathCache = new Map<string, string | null>();
+const runtimePathCache = new Map<NormalizedPath, NormalizedPath | null>();
 
 /**
  * Gets the runtime path from a workspace root path.
  * This function is cached per workspace root path.
  */
 export async function getRuntimePathFromWorkspaceRoot(
   workspaceRootPath: NormalizedPath,
-): Promise<string | null> {
+): Promise<NormalizedPath | null> {
   // Check cache first
   if (runtimePathCache.has(workspaceRootPath)) {
     return runtimePathCache.get(workspaceRootPath)!;
   }
 
   // Compute and cache
-  let rescriptRuntime: string | null =
-    config.extensionConfiguration.runtimePath ?? null;
+  let rescriptRuntime: NormalizedPath | null = normalizePath(
+    config.extensionConfiguration.runtimePath ?? null,
+  );
 
   if (rescriptRuntime !== null) {
     runtimePathCache.set(workspaceRootPath, rescriptRuntime);
@@ -539,7 +540,7 @@ export async function getRuntimePathFromWorkspaceRoot(
  */
 export async function getRuntimePathFromProjectRoot(
   projectRootPath: NormalizedPath | null,
-): Promise<string | null> {
+): Promise<NormalizedPath | null> {
   if (projectRootPath == null) {
     return null;
   }