tsc-ts 0.0.10 → 0.1.1

package/src/compiler/module-resolution.ts

@@ -104,6 +104,7 @@ const enum Features {
   Node16Default = Imports | SelfName | Exports | ExportsPatternTrailers,
   NodeNextDefault = Imports | SelfName | Exports | ExportsPatternTrailers | ImportsPatternRoot,
   BundlerDefault = Imports | SelfName | Exports | ExportsPatternTrailers | ImportsPatternRoot,
+  All = Imports | SelfName | Exports | ExportsPatternTrailers | ImportsPatternRoot,
 }
 
 function extensionsToString(extensions: number): string {
@@ -306,9 +307,11 @@ export class Resolver {
   /**
    * Called before the resolver is shared with other threads, which makes it immutable
    * (parallel-check.ts): from then on, each thread caches the results and `package.json` lookups the
-   * resolver did not have yet in tables of its own.
+   * resolver did not have yet in tables of its own. A resolver already shared (by an earlier program of
+   * a watch, which a rebuild updates: `Program.updateFile`) is immutable and stays as it is.
    */
   prepareForSharing(): void {
+    if (this.shared) return;
     this.getPathPatterns();
     this.packageJsonInfoCache.prepareForSharing();
     this.shared = true;
@@ -524,6 +527,27 @@ export class Resolver {
     return state.getPackageScopeForPath(directory);
   }
 
+  /**
+   * The TypeScript or declaration file a package's directory loads (its `typings`, `types` or `main` field, or
+   * an index file), as tsgo finds a package's main entrypoint; `''` for none.
+   */
+  loadPackageMainEntrypoint(info: PackageJsonInfo): string {
+    const state = this.entrypointState(info.packageDirectory);
+    return state.loadPackageMainEntrypoint(info);
+  }
+
+  /** The TypeScript or declaration file an `exports` target path of a package loads; `''` for none. */
+  loadPackageExportTargetEntrypoint(packageDirectory: string, candidate: string, target: string): string {
+    return this.entrypointState(packageDirectory).loadPackageExportTargetEntrypoint(candidate, target);
+  }
+
+  private entrypointState(packageDirectory: string): ResolutionState {
+    const state = new ResolutionState(this, undefined, '', packageDirectory, false, ModuleKind.None, this.options);
+    state.extensions = Extensions.TypeScript | Extensions.Declaration;
+    state.features = Features.All;
+    return state;
+  }
+
   /** Resolves an `extends` specifier of a tsconfig file. */
   resolveConfig(moduleName: string, containingFile: string): ResolvedModule {
     const state = new ResolutionState(
@@ -715,8 +739,9 @@ class ResolutionState {
             this.trace(Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
           continue;
         }
-        if (fromConfig) {
-          // Configured type roots resolve as files or directories, like modules.
+        // Configured type roots resolve as files or directories, like modules; a name ending in a separator
+        // only as a directory.
+        if (fromConfig && !hasTrailingDirectorySeparator(candidate)) {
           const fromFile = this.loadModuleFromFile(Extensions.Declaration, candidate);
           if (fromFile !== undefined) {
             this.setPackageIdFromNodeModulesPath(fromFile);
@@ -755,12 +780,13 @@ class ResolutionState {
     }
   }
 
+  /** The type root's path for the name, resolved against the type root as tsgo does: `./css` in it is `css`. */
   private getCandidateFromTypeRoot(typeRoot: string): string {
     const name =
       typeRoot.endsWith('/node_modules/@types') || typeRoot.endsWith('/node_modules/@types/')
         ? this.mangleScopedPackageName(this.name)
         : this.name;
-    return combinePaths(typeRoot, name);
+    return normalizePath(combinePaths(typeRoot, name));
   }
 
   private mangleScopedPackageName(name: string): string {
@@ -781,10 +807,12 @@ class ResolutionState {
           this.trace(Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
         continue;
       }
-      const fromFile = this.loadModuleFromFile(Extensions.Declaration, candidate);
-      if (fromFile !== undefined) {
-        this.setPackageIdFromNodeModulesPath(fromFile);
-        return fromFile;
+      if (!hasTrailingDirectorySeparator(candidate)) {
+        const fromFile = this.loadModuleFromFile(Extensions.Declaration, candidate);
+        if (fromFile !== undefined) {
+          this.setPackageIdFromNodeModulesPath(fromFile);
+          return fromFile;
+        }
       }
       const fromDirectory = this.loadNodeModuleFromDirectory(Extensions.Declaration, candidate, true);
       if (fromDirectory !== undefined) return fromDirectory;
@@ -1825,6 +1853,14 @@ class ResolutionState {
     return false;
   }
 
+  loadPackageMainEntrypoint(info: PackageJsonInfo): string {
+    return this.loadNodeModuleFromDirectoryWorker(this.extensions, info.packageDirectory, info)?.path ?? '';
+  }
+
+  loadPackageExportTargetEntrypoint(candidate: string, target: string): string {
+    return this.loadFileNameFromPackageJsonField(this.extensions, candidate, target)?.path ?? '';
+  }
+
   private loadNodeModuleFromDirectory(
     extensions: number,
     candidate: string,

package/src/compiler/module-specifiers.ts

@@ -154,6 +154,21 @@ class ResolvedPreferences {
 
 //// Entry points
 
+/** Where a module specifier came from: an existing import (None), `node_modules`, `paths`, a redirect, a relative path, or an ambient module. */
+export const enum ModuleSpecifierResultKind {
+  None,
+  NodeModules,
+  Paths,
+  Redirect,
+  Relative,
+  Ambient,
+}
+
+export interface ModuleSpecifiersResult {
+  readonly specifiers: string[];
+  readonly kind: ModuleSpecifierResultKind;
+}
+
 /**
  * Specifiers `importingFile` can import `moduleFileName` with, best first, as tsgo's
  * `GetModuleSpecifiersForFileWithInfo`. `overrideImportMode` is `None` for the file's own mode.
@@ -167,6 +182,27 @@ export function getModuleSpecifiersForFile(
   overrideImportMode: ModuleKind,
   forAutoImports: boolean,
 ): string[] {
+  return getModuleSpecifiersForFileWithInfo(
+    importingFile,
+    moduleFileName,
+    options,
+    host,
+    preferences,
+    overrideImportMode,
+    forAutoImports,
+  ).specifiers;
+}
+
+/** The specifiers `getModuleSpecifiersForFile` gives, and where they came from. */
+export function getModuleSpecifiersForFileWithInfo(
+  importingFile: SourceFile,
+  moduleFileName: string,
+  options: CompilerOptions,
+  host: ModuleSpecifierHost,
+  preferences: ModuleSpecifierPreferences,
+  overrideImportMode: ModuleKind,
+  forAutoImports: boolean,
+): ModuleSpecifiersResult {
   const modulePaths = getAllModulePaths(
     new ImporterInfo(host.getSourceOfProjectReferenceIfOutputIncluded(importingFile), host.useCaseSensitiveFileNames()),
     moduleFileName,
@@ -319,7 +355,7 @@ function computeModuleSpecifiers(
   userPreferences: ModuleSpecifierPreferences,
   overrideImportMode: ModuleKind,
   forAutoImport: boolean,
-): string[] {
+): ModuleSpecifiersResult {
   const info = new ImporterInfo(importingFile.fileName, host.useCaseSensitiveFileNames());
   const preferences = resolvePreferences(userPreferences, host, options, importingFile, '');
   const cwd = host.getCurrentDirectory();
@@ -347,7 +383,7 @@ function computeModuleSpecifiers(
     const existingMode = host.getModeForUsageLocation(importingFile, existingImport);
     // An import resolved in another mode may not resolve the same way.
     if (existingMode !== targetMode && existingMode !== ModuleKind.None && targetMode !== ModuleKind.None) continue;
-    return [text];
+    return { specifiers: [text], kind: ModuleSpecifierResultKind.None };
   }
 
   let importedFileIsInNodeModules = false;
@@ -375,7 +411,8 @@ function computeModuleSpecifiers(
     if (specifier !== '') {
       nodeModulesSpecifiers.push(specifier);
       // A specifier for a redirect is a bare package name; nothing beats it.
-      if (modulePath.isRedirect) return nodeModulesSpecifiers;
+      if (modulePath.isRedirect)
+        return { specifiers: nodeModulesSpecifiers, kind: ModuleSpecifierResultKind.NodeModules };
     }
     const local = getLocalModuleSpecifier(
       modulePath.fileName,
@@ -401,10 +438,12 @@ function computeModuleSpecifiers(
       relativeSpecifiers.push(local);
     }
   }
-  if (pathsSpecifiers.length > 0) return pathsSpecifiers;
-  if (redirectPathsSpecifiers.length > 0) return redirectPathsSpecifiers;
-  if (nodeModulesSpecifiers.length > 0) return nodeModulesSpecifiers;
-  return relativeSpecifiers;
+  if (pathsSpecifiers.length > 0) return { specifiers: pathsSpecifiers, kind: ModuleSpecifierResultKind.Paths };
+  if (redirectPathsSpecifiers.length > 0)
+    return { specifiers: redirectPathsSpecifiers, kind: ModuleSpecifierResultKind.Redirect };
+  if (nodeModulesSpecifiers.length > 0)
+    return { specifiers: nodeModulesSpecifiers, kind: ModuleSpecifierResultKind.NodeModules };
+  return { specifiers: relativeSpecifiers, kind: ModuleSpecifierResultKind.Relative };
 }
 
 /** A specifier through `paths`, `package.json` `imports`, `rootDirs` or a relative path. */
@@ -678,9 +717,19 @@ function tryGetModuleNameAsNodeModule(
 ): string {
   const parts = getNodeModulePathParts(modulePath.fileName);
   if (parts === undefined) return '';
+  // Only a `node_modules` in the importing file's directory or above can be used, and not the global typings
+  // cache. This is checked before `exports`, which can give a bare specifier directly.
+  const caseSensitive = host.useCaseSensitiveFileNames();
+  const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation();
+  const pathToTopLevelNodeModules = modulePath.fileName.slice(0, parts.topLevelNodeModulesIndex);
+  if (
+    !hasPrefix(info.sourceDirectory, pathToTopLevelNodeModules, caseSensitive) ||
+    (globalTypingsCacheLocation !== '' &&
+      hasPrefix(globalTypingsCacheLocation, pathToTopLevelNodeModules, caseSensitive))
+  )
+    return '';
   const preferences = resolvePreferences(userPreferences, host, options, importingFile, '');
   const allowedEndings = preferences.allowedEndings(ModuleKind.None);
-  const caseSensitive = host.useCaseSensitiveFileNames();
   let moduleSpecifier = modulePath.fileName;
   let isPackageRootPath = false;
   if (!packageNameOnly) {
@@ -706,16 +755,6 @@ function tryGetModuleNameAsNodeModule(
   }
   if (modulePath.isRedirect && !isPackageRootPath) return '';
 
-  // Only a `node_modules` in the importing file's directory or above can be used, and not the
-  // global typings cache.
-  const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation();
-  const pathToTopLevelNodeModules = moduleSpecifier.slice(0, parts.topLevelNodeModulesIndex);
-  if (
-    !hasPrefix(info.sourceDirectory, pathToTopLevelNodeModules, caseSensitive) ||
-    (globalTypingsCacheLocation !== '' &&
-      hasPrefix(globalTypingsCacheLocation, pathToTopLevelNodeModules, caseSensitive))
-  )
-    return '';
   // A package found in `@types` is imported by its own name.
   return getPackageNameFromTypesPackageName(moduleSpecifier.slice(parts.topLevelPackageNameIndex + 1));
 }
@@ -1285,7 +1324,8 @@ export function getAllowedEndingsInPreferredOrder(
   syntaxImpliedNodeFormat: ModuleKind,
 ): ModuleSpecifierEnding[] {
   let preferred = getPreferredEnding(preferences, host, options, importingFile, oldImportSpecifier, ModuleKind.None);
-  if (host.getDefaultResolutionModeForFile(importingFile) !== syntaxImpliedNodeFormat)
+  const resolutionMode = host.getDefaultResolutionModeForFile(importingFile);
+  if (resolutionMode !== syntaxImpliedNodeFormat)
     preferred = getPreferredEnding(
       preferences,
       host,
@@ -1295,7 +1335,9 @@ export function getAllowedEndingsInPreferredOrder(
       syntaxImpliedNodeFormat,
     );
   const allowTs = shouldAllowImportingTsExtension(options, importingFile.fileName);
-  if (syntaxImpliedNodeFormat === ModuleKind.ESNext && isNodeNext(options))
+  // Without a mode implied by the syntax, the file's default resolution mode applies.
+  const effectiveSyntaxMode = syntaxImpliedNodeFormat !== ModuleKind.None ? syntaxImpliedNodeFormat : resolutionMode;
+  if (effectiveSyntaxMode === ModuleKind.ESNext && isNodeNext(options))
     return allowTs
       ? [ModuleSpecifierEnding.TsExtension, ModuleSpecifierEnding.JsExtension]
       : [ModuleSpecifierEnding.JsExtension];

package/src/compiler/name-resolver.ts

@@ -172,13 +172,20 @@ export class NameResolver {
         current = current.parent;
         if (current === undefined) break;
       }
+      // A module's import attributes type sees neither the module's locals nor its exports.
+      const isModuleAttributes =
+        current.kind === SyntaxKind.ModuleDeclaration &&
+        (current as ModuleDeclaration).attributes !== undefined &&
+        lastLocation === (current as ModuleDeclaration).attributes;
       const locals = getLocalsOf(current);
       // Locals of a global source file are merged into the globals.
       if (locals !== undefined && !isGlobalSourceFile(current)) {
         result = this.lookup(locals, name, meaning);
         if (result !== undefined) {
           let useResult = true;
-          if (isFunctionLike(current) && lastLocation !== undefined && lastLocation !== getBody(current)) {
+          if (isModuleAttributes) {
+            useResult = false;
+          } else if (isFunctionLike(current) && lastLocation !== undefined && lastLocation !== getBody(current)) {
             // Type parameters are in scope in the whole signature, but local types only in the
             // body; parameters only in the body, parameter list and return type. JSDoc types
             // are parented above type parameters, so this doesn't apply to them.
@@ -215,6 +222,7 @@ export class NameResolver {
         case SyntaxKind.SourceFile:
         case SyntaxKind.ModuleDeclaration: {
           if (current.kind === SyntaxKind.SourceFile && !isExternalOrCommonJSModule(current as SourceFile)) break;
+          if (isModuleAttributes) break;
           const moduleSymbol = this.getSymbolOfDeclaration(current);
           if (moduleSymbol === undefined) break;
           const moduleExports = moduleSymbol.exports ?? emptyTable;