skir 1.1.2 → 1.1.4

package/src/module_set.ts

@@ -35,7 +35,6 @@ import {
   type UnresolvedType,
   type Value,
 } from "skir-internal";
-import { FileReader } from "./io.js";
 import {
   isStringLiteral,
   literalValueToDenseJson,
@@ -43,37 +42,52 @@ import {
   valueHasPrimitiveType,
 } from "./literals.js";
 import { parseModule } from "./parser.js";
-import { tokenizeModule } from "./tokenizer.js";
+import { ModuleTokens, tokenizeModule } from "./tokenizer.js";
 
+/**
+ * Result of compiling a set of modules. Immutable.
+ *
+ * Support incremental compilation by accepting an optional cache of the previous
+ * module set. This cache can be used to avoid re-parsing and re-resolving
+ * modules that haven't changed since the last compilation.
+ */
 export class ModuleSet {
-  static create(fileReader: FileReader, rootPath: string): ModuleSet {
-    return new ModuleSet(new DefaultModuleParser(fileReader, rootPath));
+  static compile(
+    modulePathToContent: ReadonlyMap<string, string>,
+    cache?: ModuleSet,
+    parseMode: "strict" | "lenient" = "strict",
+  ): ModuleSet {
+    return new ModuleSet(modulePathToContent, cache, parseMode);
   }
 
-  static fromMap(map: ReadonlyMap<string, string>): ModuleSet {
-    const result = new ModuleSet(new MapBasedModuleParser(map));
-    for (const modulePath of map.keys()) {
-      result.parseAndResolve(modulePath);
+  constructor(
+    private readonly modulePathToContent: ReadonlyMap<string, string>,
+    cache: ModuleSet | undefined,
+    private readonly parseMode: "strict" | "lenient",
+  ) {
+    this.cache = cache
+      ? new Cache(modulePathToContent, cache.moduleBundles)
+      : undefined;
+    for (const modulePath of modulePathToContent.keys()) {
+      this.parseAndResolve(modulePath, new Set<string>());
     }
-    return result;
+    this.finalizationResult = this.finalize();
+    // So it can be garbage collected.
+    this.cache = undefined;
   }
 
-  constructor(private readonly moduleParser: ModuleParser) {}
-
-  parseAndResolve(
+  private parseAndResolve(
     modulePath: string,
-    inProgressSet?: Set<string>,
-  ): Result<Module | null> {
-    const inMap = this.mutableModules.get(modulePath);
+    inProgressSet: Set<string>,
+  ): ModuleBundle | null {
+    const inMap = this.moduleBundles.get(modulePath);
     if (inMap !== undefined) {
       return inMap;
     }
-    const result = this.doParseAndResolve(
-      modulePath,
-      inProgressSet || new Set<string>(),
-    );
-    this.mutableModules.set(modulePath, result);
-    this.mutableErrors.push(...result.errors);
+    const result = this.doParseAndResolve(modulePath, inProgressSet);
+    if (result) {
+      this.moduleBundles.set(modulePath, result);
+    }
     return result;
   }
 
@@ -81,19 +95,46 @@ export class ModuleSet {
   private doParseAndResolve(
     modulePath: string,
     inProgressSet: Set<string>,
-  ): Result<Module | null> {
-    const errors: SkirError[] = [];
+  ): ModuleBundle | null {
+    const moduleContent = this.modulePathToContent.get(modulePath);
+    if (moduleContent === undefined) {
+      return null;
+    }
 
-    let module: MutableModule;
+    let moduleTokens: Result<ModuleTokens>;
     {
-      const parseResult = this.moduleParser.parseModule(modulePath);
-      if (parseResult.result === null) {
-        return parseResult;
+      const moduleCacheResult = this.cache?.getModuleCacheResult(
+        modulePath,
+      ) ?? { kind: "no-cache" };
+      switch (moduleCacheResult.kind) {
+        case "no-cache": {
+          moduleTokens = tokenizeModule(moduleContent, modulePath);
+          break;
+        }
+        case "module-tokens": {
+          moduleTokens = moduleCacheResult.tokens;
+          break;
+        }
+        case "module-bundle": {
+          this.registry.mergeFrom(moduleCacheResult.bundle.registry);
+          return moduleCacheResult.bundle;
+        }
       }
+    }
+
+    let module: MutableModule;
+    const errors: SkirError[] = [];
+    {
+      const parseResult = parseModule(moduleTokens.result, this.parseMode);
       errors.push(...parseResult.errors);
       module = parseResult.result;
     }
 
+    const moduleBundle = new ModuleBundle(moduleTokens, {
+      result: module,
+      errors: errors,
+    });
+
     // Process all imports.
     const pathToImports = new Map<string, Array<Import | ImportAlias>>();
     for (const declaration of module.declarations) {
@@ -133,13 +174,21 @@ export class ModuleSet {
       const otherModule = this.parseAndResolve(otherModulePath, inProgressSet);
       inProgressSet.delete(modulePath);
 
-      if (otherModule.result === null) {
+      if (otherModule === null) {
         errors.push({
           token: declaration.modulePath,
           message: "Module not found",
+          expectedNames: suggestModulePaths(
+            unquoteAndUnescape(declaration.modulePath.text),
+            modulePath,
+            this.modulePathToContent,
+          ),
         });
-      } else if (otherModule.errors.length !== 0) {
-        const hasCircularDependency = otherModule.errors.some(
+      } else if (
+        otherModule.tokens.errors.length !== 0 ||
+        otherModule.module.errors.length !== 0
+      ) {
+        const hasCircularDependency = otherModule.module.errors.some(
           (e) => e.message === circularDependencyMessage,
         );
         if (hasCircularDependency) {
@@ -159,13 +208,13 @@ export class ModuleSet {
         // module and are not imported symbols themselves.
         for (const importedName of declaration.importedNames) {
           const importedDeclaration =
-            otherModule.result.nameToDeclaration[importedName.text];
+            otherModule.module.result.nameToDeclaration[importedName.text];
           if (importedDeclaration === undefined) {
             errors.push({
               token: importedName,
               message: "Not found",
               expectedNames: declarationsToExpectedNames(
-                otherModule.result.nameToDeclaration,
+                otherModule.module.result.nameToDeclaration,
                 (d) => d.kind === "record",
               ),
             });
@@ -185,7 +234,7 @@ export class ModuleSet {
     }
 
     const pathToImportedNames = module.pathToImportedNames;
-    for (const [path, imports] of pathToImports.entries()) {
+    for (const [path, imports] of pathToImports) {
       const importsNoAlias = imports.filter(
         (i): i is Import => i.kind === "import",
       );
@@ -232,38 +281,21 @@ export class ModuleSet {
       }
     }
 
-    const result: Result<Module> = {
-      result: module,
-      errors: errors,
-    };
-
     if (errors.length) {
-      return result;
+      return moduleBundle;
     }
 
-    this.mutableResolvedModules.push(module);
-
     // We can't merge these 3 loops into a single one, each operation must run
     // after the last operation ran on the whole map.
 
     // Loop 1: merge the module records map into the cross-module record map.
     for (const record of module.records) {
       const { key } = record.record;
-      this.mutableRecordMap.set(key, record);
+      this.registry.recordMap.set(key, record);
+      moduleBundle.registry.recordMap.set(key, record);
       const { recordNumber } = record.record;
       if (recordNumber != null && !modulePath.startsWith("@")) {
-        const existing = this.numberToRecord.get(recordNumber);
-        if (existing === undefined) {
-          this.numberToRecord.set(recordNumber, key);
-        } else {
-          const otherRecord = this.recordMap.get(existing)!;
-          const otherRecordName = otherRecord.record.name.text;
-          const otherModulePath = otherRecord.modulePath;
-          errors.push({
-            token: record.record.name,
-            message: `Same number as ${otherRecordName} in ${otherModulePath}`,
-          });
-        }
+        moduleBundle.registry.pushNumberRecord(recordNumber, key);
       }
     }
 
@@ -272,7 +304,7 @@ export class ModuleSet {
     const usedImports = new Set<string>();
     const typeResolver = new TypeResolver(
       module,
-      this.mutableModules,
+      this.moduleBundles,
       usedImports,
       errors,
     );
@@ -326,20 +358,8 @@ export class ModuleSet {
           this.validateArrayKeys(responseType, errors);
         }
       }
-      if (!modulePath.startsWith("@")) {
-        const { number } = method;
-        const existing = this.numberToMethod.get(number);
-        if (existing === undefined) {
-          this.numberToMethod.set(number, method);
-        } else {
-          const otherMethodName = existing.name.text;
-          const otherModulePath = existing.name.line.modulePath;
-          errors.push({
-            token: method.name,
-            message: `Same number as ${otherMethodName} in ${otherModulePath}`,
-          });
-        }
-      }
+      const { number } = method;
+      moduleBundle.registry.pushNumberMethod(number, method);
       // Resolve the references in the doc comments of the method.
       this.resolveDocReferences(method, module, errors);
     }
@@ -359,7 +379,9 @@ export class ModuleSet {
 
     ensureAllImportsAreUsed(module, usedImports, errors);
 
-    return result;
+    this.registry.mergeFrom(moduleBundle.registry);
+
+    return moduleBundle;
   }
 
   private storeResolvedFieldTypes(
@@ -915,8 +937,8 @@ export class ModuleSet {
             if (!resolvedModulePath) {
               return false;
             }
-            const importedModule = this.mutableModules.get(resolvedModulePath!);
-            if (!importedModule?.result) {
+            const importedModule = this.moduleBundles.get(resolvedModulePath!);
+            if (!importedModule) {
               return false;
             }
             let newNameChain: readonly MutableDocReferenceName[];
@@ -929,7 +951,7 @@ export class ModuleSet {
             return tryResolveReference(
               ref,
               newNameChain,
-              importedModule.result,
+              importedModule.module.result,
             );
           }
           case "constant":
@@ -944,7 +966,7 @@ export class ModuleSet {
       }
     };
 
-    const { recordMap } = this;
+    const { recordMap } = this.registry;
     // Build list of naming scopes to search, in order of priority.
     const scopes: Array<Record | Module> = [];
     const pushRecordAncestorsToScopes = (record: Record): void => {
@@ -1012,56 +1034,107 @@ export class ModuleSet {
     }
   }
 
-  mergeFrom(other: ModuleSet): void {
-    for (const [key, value] of other.mutableModules.entries()) {
-      this.mutableModules.set(key, value);
+  finalize(): FinalizationResult {
+    type MutableModuleResult = {
+      result: Module;
+      errors: SkirError[];
+    };
+    const modules = new Map<string, MutableModuleResult>();
+
+    for (const [modulePath, moduleBundle] of this.moduleBundles) {
+      const { module, tokens } = moduleBundle;
+      const moduleErrors = tokens.errors.length ? tokens.errors : module.errors;
+      modules.set(modulePath, {
+        result: module.result,
+        errors: [...moduleErrors],
+      });
     }
-    for (const [key, value] of other.recordMap.entries()) {
-      this.mutableRecordMap.set(key, value);
+
+    // Look for duplicate method numbers.
+    for (const methods of this.registry.numberToMethods.values()) {
+      if (methods.length <= 1) {
+        continue;
+      }
+      const pushError = (method: Method, other: Method): void => {
+        const modulePath = method.name.line.modulePath;
+        const moduleResult = modules.get(modulePath)!;
+        const otherMethodName = other.name.text;
+        const otherModulePath = other.name.line.modulePath;
+        moduleResult.errors.push({
+          token: method.name,
+          message: `Same number as ${otherMethodName} in ${otherModulePath}`,
+        });
+      };
+      pushError(methods[0]!, methods[1]!);
+      for (let i = 1; i < methods.length; ++i) {
+        pushError(methods[i]!, methods[0]!);
+      }
     }
-    this.mutableResolvedModules.push(...other.resolvedModules);
-    for (const [key, value] of other.numberToRecord.entries()) {
-      this.numberToRecord.set(key, value);
+
+    // Look for duplicate record numbers.
+    for (const records of this.registry.numberToRecords.values()) {
+      if (records.length <= 1) {
+        continue;
+      }
+      const pushError = (recordKey: RecordKey, otherKey: RecordKey): void => {
+        const record = this.registry.recordMap.get(recordKey)!;
+        const other = this.registry.recordMap.get(otherKey)!;
+
+        const modulePath = record.record.name.line.modulePath;
+        const moduleResult = modules.get(modulePath)!;
+        const otherRecordName = other.record.name.text;
+        const otherModulePath = other.modulePath;
+        moduleResult.errors.push({
+          token: record.record.name,
+          message: `Same number as ${otherRecordName} in ${otherModulePath}`,
+        });
+      };
+      pushError(records[0]!, records[1]!);
+      for (let i = 1; i < records.length; ++i) {
+        pushError(records[i]!, records[0]!);
+      }
     }
-    for (const [key, value] of other.numberToMethod.entries()) {
-      this.numberToMethod.set(key, value);
+
+    // Aggregate errors across all modules.
+    const errors: SkirError[] = [];
+    for (const moduleBundle of modules.values()) {
+      errors.push(...moduleBundle.errors);
     }
-    this.mutableErrors.push(...other.errors);
+    return {
+      modules: modules,
+      errors: errors,
+    };
   }
 
-  private readonly mutableModules = new Map<string, Result<Module | null>>();
-  private readonly mutableRecordMap = new Map<RecordKey, RecordLocation>();
-  private readonly mutableResolvedModules: Module[] = [];
-  private readonly numberToRecord = new Map<number, RecordKey>();
-  private readonly numberToMethod = new Map<number, Method>();
-  private readonly mutableErrors: SkirError[] = [];
+  // BEGIN PROPERTIES
+  private cache: Cache | undefined;
+  private readonly moduleBundles = new Map<string, ModuleBundle>();
+  private readonly registry = new DeclarationRegistry();
+  private readonly finalizationResult: FinalizationResult;
+  // END PROPERTIES
 
-  get modules(): ReadonlyMap<string, Result<Module | null>> {
-    return this.mutableModules;
-  }
-
-  get recordMap(): ReadonlyMap<RecordKey, RecordLocation> {
-    return this.mutableRecordMap;
+  findRecordByNumber(recordNumber: number): RecordLocation | undefined {
+    const { numberToRecords, recordMap } = this.registry;
+    const recordKeys = numberToRecords.get(recordNumber);
+    return recordKeys?.length === 1 ? recordMap.get(recordKeys[0]!) : undefined;
   }
 
-  get resolvedModules(): ReadonlyArray<Module> {
-    return this.mutableResolvedModules;
+  findMethodByNumber(methodNumber: number): Method | undefined {
+    const { numberToMethods } = this.registry;
+    const methods = numberToMethods.get(methodNumber);
+    return methods?.length === 1 ? methods[0]! : undefined;
   }
 
-  findRecordByNumber(recordNumber: number): RecordLocation | undefined {
-    const recordKey = this.numberToRecord.get(recordNumber);
-    if (recordKey === undefined) {
-      return undefined;
-    }
-    return this.recordMap.get(recordKey);
+  get recordMap(): ReadonlyMap<RecordKey, RecordLocation> {
+    return this.registry.recordMap;
   }
 
-  findMethodByNumber(methodNumber: number): Method | undefined {
-    return this.numberToMethod.get(methodNumber);
+  get errors(): readonly SkirError[] {
+    return this.finalizationResult.errors;
   }
 
-  get errors(): readonly SkirError[] {
-    return this.mutableErrors;
+  get modules(): ReadonlyMap<string, Result<Module>> {
+    return this.finalizationResult.modules;
   }
 }
 
@@ -1150,7 +1223,7 @@ function validateKeyedItems(
 class TypeResolver {
   constructor(
     private readonly module: Module,
-    private readonly modules: Map<string, Result<Module | null>>,
+    private readonly moduleBundles: Map<string, ModuleBundle>,
     private readonly usedImports: Set<string>,
     private readonly errors: ErrorSink,
   ) {}
@@ -1196,7 +1269,7 @@ class TypeResolver {
     // reference, or the module if the record reference is absolute (starts with
     // a dot).
     let start: Record | Module | undefined;
-    const { errors, module, modules, usedImports } = this;
+    const { errors, module, moduleBundles: modules, usedImports } = this;
     if (recordOrigin !== "top-level") {
       if (!recordRef.absolute) {
         // Traverse the chain of ancestors from most nested to top-level.
@@ -1269,12 +1342,12 @@ class TypeResolver {
           return undefined;
         }
         const newModuleResult = modules.get(newModulePath);
-        if (newModuleResult === undefined || newModuleResult.result === null) {
+        if (!newModuleResult) {
           // The module was not found or has errors: an error was already
           // registered, no need to register a new one.
           return undefined;
         }
-        const newModule = newModuleResult.result;
+        const newModule = newModuleResult.module.result;
         if (newIt.kind === "import") {
           newIt = newModule.nameToDeclaration[name];
           if (!newIt) {
@@ -1322,6 +1395,145 @@ class TypeResolver {
   }
 }
 
+type ModuleCacheResult =
+  | {
+      kind: "no-cache";
+    }
+  | {
+      kind: "module-tokens";
+      tokens: Result<ModuleTokens>;
+    }
+  | {
+      kind: "module-bundle";
+      bundle: ModuleBundle;
+    };
+
+class Cache {
+  private readonly modulePathToCacheResult = new Map<
+    string,
+    ModuleCacheResult
+  >();
+
+  constructor(
+    modulePathToNewContent: ReadonlyMap<string, string>,
+    private readonly modulePathToOldBundle: ReadonlyMap<string, ModuleBundle>,
+  ) {
+    const unchangedModulePaths = new Set<string>();
+    for (const [modulePath, newContent] of modulePathToNewContent) {
+      const oldBundle = modulePathToOldBundle.get(modulePath);
+      if (oldBundle?.tokens.result.sourceCode === newContent) {
+        unchangedModulePaths.add(modulePath);
+      }
+    }
+    const classify = (modulePath: string): ModuleCacheResult => {
+      const oldBundle = modulePathToOldBundle.get(modulePath);
+      if (!oldBundle) {
+        return { kind: "no-cache" };
+      }
+      {
+        const inMap = this.modulePathToCacheResult.get(modulePath);
+        if (inMap) {
+          return inMap;
+        }
+      }
+      let result: ModuleCacheResult;
+      const newContent = modulePathToNewContent.get(modulePath);
+      if (newContent === oldBundle.tokens.result.sourceCode) {
+        // Assume best case, may downgrade later.
+        this.modulePathToCacheResult.set(modulePath, {
+          kind: "module-bundle",
+          bundle: oldBundle,
+        });
+        const directDependencies = Object.keys(
+          oldBundle.module.result?.pathToImportedNames,
+        );
+        result = directDependencies.every(
+          (dep) => classify(dep).kind === "module-bundle",
+        )
+          ? { kind: "module-bundle", bundle: oldBundle }
+          : { kind: "module-tokens", tokens: oldBundle.tokens };
+      } else {
+        result = { kind: "no-cache" };
+      }
+      this.modulePathToCacheResult.set(modulePath, result);
+      return result;
+    };
+    for (const modulePath of modulePathToOldBundle.keys()) {
+      classify(modulePath);
+    }
+  }
+
+  getModuleCacheResult(modulePath: string): ModuleCacheResult {
+    return this.modulePathToCacheResult.get(modulePath) ?? { kind: "no-cache" };
+  }
+}
+
+/** Registry of declarations possibly across multiple modules. */
+class DeclarationRegistry {
+  readonly recordMap = new Map<RecordKey, RecordLocation>();
+  readonly numberToRecords = new Map<number, RecordKey[]>();
+  readonly numberToMethods = new Map<number, Method[]>();
+
+  mergeFrom(other: DeclarationRegistry): void {
+    for (const [key, value] of other.recordMap) {
+      this.recordMap.set(key, value);
+    }
+    for (const [number, value] of other.numberToRecords) {
+      let existing = this.numberToRecords.get(number);
+      if (!existing) {
+        existing = [];
+        this.numberToRecords.set(number, existing);
+      }
+      existing.push(...value);
+    }
+    for (const [number, value] of other.numberToMethods) {
+      let existing = this.numberToMethods.get(number);
+      if (!existing) {
+        existing = [];
+        this.numberToMethods.set(number, existing);
+      }
+      existing.push(...value);
+    }
+  }
+
+  pushNumberRecord(number: number, record: RecordKey): void {
+    let value = this.numberToRecords.get(number);
+    if (!value) {
+      value = [];
+      this.numberToRecords.set(number, value);
+    }
+    value.push(record);
+  }
+
+  pushNumberMethod(number: number, method: Method): void {
+    let value = this.numberToMethods.get(number);
+    if (!value) {
+      value = [];
+      this.numberToMethods.set(number, value);
+    }
+    value.push(method);
+  }
+}
+
+class ModuleBundle {
+  constructor(
+    readonly tokens: Result<ModuleTokens>,
+    readonly module: Result<Module>,
+  ) {}
+
+  /**
+   * Registry of declarations found in this module only.
+   * Will be merged into the "global" registry.
+   */
+  readonly registry = new DeclarationRegistry();
+}
+
+interface FinalizationResult {
+  readonly modules: ReadonlyMap<string, Result<Module>>;
+  /** Errors aggregated across all modules. */
+  readonly errors: readonly SkirError[];
+}
+
 function ensureAllImportsAreUsed(
   module: Module,
   usedImports: Set<string>,
@@ -1348,55 +1560,94 @@ function ensureAllImportsAreUsed(
   }
 }
 
-export interface ModuleParser {
-  parseModule(modulePath: string): Result<MutableModule | null>;
-}
-
-abstract class ModuleParserBase implements ModuleParser {
-  abstract readSourceCode(modulePath: string): string | undefined;
-
-  parseModule(modulePath: string): Result<MutableModule | null> {
-    const code = this.readSourceCode(modulePath);
-    if (code === undefined) {
-      return {
-        result: null,
-        errors: [],
-      };
-    }
-
-    const tokens = tokenizeModule(code, modulePath);
-    if (tokens.errors.length !== 0) {
-      return {
-        result: null,
-        errors: tokens.errors,
-      };
-    }
-
-    return parseModule(tokens.result, "strict");
-  }
-}
-
-class DefaultModuleParser extends ModuleParserBase {
-  constructor(
-    private readonly fileReader: FileReader,
-    private readonly rootPath: string,
-  ) {
-    super();
+/**
+ * Returns suggested module paths for import auto-completion.
+ *
+ * Given the partial path the user has typed, returns suggestions from
+ * `modulePathToContent`. For paths where there is more after the matched
+ * segment, the suggestion is truncated at the next "/" and a trailing "/" is
+ * appended to signal that it is a directory, not a file.
+ *
+ * Handles both absolute paths (e.g. "bb/ee") and relative paths (e.g.
+ * "./other", "../sibling").
+ */
+function suggestModulePaths(
+  typedPath: string,
+  originModulePath: string,
+  modulePathToContent: ReadonlyMap<string, string>,
+): ReadonlyArray<{ readonly name: string }> {
+  const isRelative = typedPath.startsWith("./") || typedPath.startsWith("../");
+
+  // Compute the absolute path prefix to match against all module paths.
+  let absolutePrefix: string;
+  if (isRelative) {
+    // Split at the last "/" so that the directory component (fully typed) can
+    // be resolved cleanly, while the tail (partial filename/dir prefix) is
+    // appended afterwards.
+    const lastSlash = typedPath.lastIndexOf("/");
+    const dirComponent = typedPath.slice(0, lastSlash + 1);
+    const filePrefix = typedPath.slice(lastSlash + 1);
+    // Append a dummy filename so Paths.join/normalize treat the directory
+    // component as a file path (avoids trailing-slash edge-cases), then strip
+    // it off again.
+    const dummy = dirComponent + "__dummy__";
+    const resolvedDummy = Paths.join(
+      Paths.dirname(originModulePath),
+      dummy.startsWith("./") ? dummy.slice(2) : dummy,
+    ).replace(/\\/g, "/");
+    const absoluteDir = resolvedDummy.slice(
+      0,
+      resolvedDummy.length - "__dummy__".length,
+    );
+    absolutePrefix = absoluteDir + filePrefix;
+  } else if (originModulePath.startsWith("@") && !typedPath.startsWith("@")) {
+    // Mirror the package-prefix logic from resolveModulePath.
+    absolutePrefix = extractPackagePrefix(originModulePath) + typedPath;
+  } else {
+    absolutePrefix = typedPath;
   }
-
-  readSourceCode(modulePath: string): string | undefined {
-    return this.fileReader.readTextFile(Paths.join(this.rootPath, modulePath));
+  absolutePrefix = absolutePrefix.replace(/\\/g, "/");
+  if (absolutePrefix.startsWith("../")) {
+    // Typed path escapes the root; no valid suggestions.
+    return [];
   }
-}
 
-class MapBasedModuleParser extends ModuleParserBase {
-  constructor(private readonly moduleMap: ReadonlyMap<string, string>) {
-    super();
+  const originBaseDir = Paths.dirname(originModulePath).replace(/\\/g, "/");
+  const suggestions = new Set<string>();
+
+  for (const path of modulePathToContent.keys()) {
+    if (!path.startsWith(absolutePrefix)) continue;
+    const remaining = path.slice(absolutePrefix.length);
+    const slashIndex = remaining.indexOf("/");
+    // If there is a sub-path after the matched prefix, collapse to the next
+    // directory segment and append "/". Otherwise use the full path.
+    const absoluteSuggestion =
+      slashIndex >= 0
+        ? absolutePrefix + remaining.slice(0, slashIndex + 1)
+        : path;
+
+    if (isRelative) {
+      const isDir = absoluteSuggestion.endsWith("/");
+      const absPath = isDir
+        ? absoluteSuggestion.slice(0, -1)
+        : absoluteSuggestion;
+      let rel = Paths.relative(originBaseDir, absPath).replace(/\\/g, "/");
+      // Paths.relative returns "" when both paths are the same; normalise to
+      // "." so the subsequent prefix-check and directory-slash logic work
+      // correctly (avoids producing the invalid path ".//" for same-dir cases).
+      if (rel === "") {
+        rel = ".";
+      }
+      if (!rel.startsWith(".")) {
+        rel = "./" + rel;
+      }
+      suggestions.add(isDir ? rel + "/" : rel);
+    } else {
+      suggestions.add(absoluteSuggestion);
+    }
   }
 
-  readSourceCode(modulePath: string): string | undefined {
-    return this.moduleMap.get(modulePath);
-  }
+  return [...suggestions].map((name) => ({ name }));
 }
 
 function resolveModulePath(