tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/module-specifiers.d.ts

@@ -43,11 +43,26 @@ export declare abstract class ModuleSpecifierHost {
     /** For output paths of `package.json` `imports` targets. */
     abstract getOutputPathsHost(): OutputPathsHost;
 }
+/** Where a module specifier came from: an existing import (None), `node_modules`, `paths`, a redirect, a relative path, or an ambient module. */
+export declare const enum ModuleSpecifierResultKind {
+    None = 0,
+    NodeModules = 1,
+    Paths = 2,
+    Redirect = 3,
+    Relative = 4,
+    Ambient = 5
+}
+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.
  */
 export declare function getModuleSpecifiersForFile(importingFile: SourceFile, moduleFileName: string, options: CompilerOptions, host: ModuleSpecifierHost, preferences: ModuleSpecifierPreferences, overrideImportMode: ModuleKind, forAutoImports: boolean): string[];
+/** The specifiers `getModuleSpecifiersForFile` gives, and where they came from. */
+export declare function getModuleSpecifiersForFileWithInfo(importingFile: SourceFile, moduleFileName: string, options: CompilerOptions, host: ModuleSpecifierHost, preferences: ModuleSpecifierPreferences, overrideImportMode: ModuleKind, forAutoImports: boolean): ModuleSpecifiersResult;
 /** Number of `/` in a specifier, ignoring a leading `./`. */
 export declare function countPathComponents(path: string): number;
 /** The package name of a file or directory in `node_modules`, or `''`. */

package/dist/api/compiler/module-specifiers.js

@@ -65,12 +65,15 @@ class ResolvedPreferences {
         return getAllowedEndingsInPreferredOrder(this.preferences, this.host, this.options, this.importingFile, this.oldImportSpecifier, syntaxImpliedNodeFormat);
     }
 }
-//// Entry points
 /**
  * Specifiers `importingFile` can import `moduleFileName` with, best first, as tsgo's
  * `GetModuleSpecifiersForFileWithInfo`. `overrideImportMode` is `None` for the file's own mode.
  */
 export function getModuleSpecifiersForFile(importingFile, moduleFileName, options, host, preferences, overrideImportMode, forAutoImports) {
+    return getModuleSpecifiersForFileWithInfo(importingFile, moduleFileName, options, host, preferences, overrideImportMode, forAutoImports).specifiers;
+}
+/** The specifiers `getModuleSpecifiersForFile` gives, and where they came from. */
+export function getModuleSpecifiersForFileWithInfo(importingFile, moduleFileName, options, host, preferences, overrideImportMode, forAutoImports) {
     const modulePaths = getAllModulePaths(new ImporterInfo(host.getSourceOfProjectReferenceIfOutputIncluded(importingFile), host.useCaseSensitiveFileNames()), moduleFileName, host);
     return computeModuleSpecifiers(modulePaths, options, importingFile, host, preferences, overrideImportMode, forAutoImports);
 }
@@ -231,7 +234,7 @@ function computeModuleSpecifiers(modulePaths, options, importingFile, host, user
         // 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: 0 /* ModuleSpecifierResultKind.None */ };
     }
     let importedFileIsInNodeModules = false;
     for (const p of modulePaths)
@@ -251,7 +254,7 @@ function computeModuleSpecifiers(modulePaths, options, importingFile, host, user
             nodeModulesSpecifiers.push(specifier);
             // A specifier for a redirect is a bare package name; nothing beats it.
             if (modulePath.isRedirect)
-                return nodeModulesSpecifiers;
+                return { specifiers: nodeModulesSpecifiers, kind: 1 /* ModuleSpecifierResultKind.NodeModules */ };
         }
         const local = getLocalModuleSpecifier(modulePath.fileName, info, options, host, targetMode, preferences, modulePath.isRedirect || specifier !== '');
         if (local === '')
@@ -275,12 +278,12 @@ function computeModuleSpecifiers(modulePaths, options, importingFile, host, user
         }
     }
     if (pathsSpecifiers.length > 0)
-        return pathsSpecifiers;
+        return { specifiers: pathsSpecifiers, kind: 2 /* ModuleSpecifierResultKind.Paths */ };
     if (redirectPathsSpecifiers.length > 0)
-        return redirectPathsSpecifiers;
+        return { specifiers: redirectPathsSpecifiers, kind: 3 /* ModuleSpecifierResultKind.Redirect */ };
     if (nodeModulesSpecifiers.length > 0)
-        return nodeModulesSpecifiers;
-    return relativeSpecifiers;
+        return { specifiers: nodeModulesSpecifiers, kind: 1 /* ModuleSpecifierResultKind.NodeModules */ };
+    return { specifiers: relativeSpecifiers, kind: 4 /* ModuleSpecifierResultKind.Relative */ };
 }
 /** A specifier through `paths`, `package.json` `imports`, `rootDirs` or a relative path. */
 function getLocalModuleSpecifier(moduleFileName, info, options, host, importMode, preferences, pathsOnly) {
@@ -489,9 +492,17 @@ function tryGetModuleNameAsNodeModule(modulePath, info, importingFile, host, opt
     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) {
@@ -512,14 +523,6 @@ function tryGetModuleNameAsNodeModule(modulePath, info, importingFile, host, opt
     }
     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));
 }
@@ -914,10 +917,13 @@ function getPreferredEnding(preferences, host, options, importingFile, oldImport
 /** The endings a specifier from `importingFile` may have, most preferred first. */
 export function getAllowedEndingsInPreferredOrder(preferences, host, options, importingFile, oldImportSpecifier, syntaxImpliedNodeFormat) {
     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, options, importingFile, oldImportSpecifier, 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
             ? [3 /* ModuleSpecifierEnding.TsExtension */, 2 /* ModuleSpecifierEnding.JsExtension */]
             : [2 /* ModuleSpecifierEnding.JsExtension */];

package/dist/api/compiler/name-resolver.js

@@ -76,7 +76,7 @@ export class NameResolver {
             if (nameIsConst && isConstAssertion(current))
                 return undefined;
             // From the name of a namespace or enum, skip its own scope: its locals could conflict.
-            if ((current.kind === 268 /* SyntaxKind.ModuleDeclaration */ || current.kind === 267 /* SyntaxKind.EnumDeclaration */) &&
+            if ((current.kind === 269 /* SyntaxKind.ModuleDeclaration */ || current.kind === 268 /* SyntaxKind.EnumDeclaration */) &&
                 lastLocation !== undefined &&
                 getName(current) === lastLocation) {
                 lastLocation = current;
@@ -84,25 +84,32 @@ export class NameResolver {
                 if (current === undefined)
                     break;
             }
+            // A module's import attributes type sees neither the module's locals nor its exports.
+            const isModuleAttributes = current.kind === 269 /* SyntaxKind.ModuleDeclaration */ &&
+                current.attributes !== undefined &&
+                lastLocation === current.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.
-                        if ((meaning & result.flags & 788968 /* SymbolFlags.Type */) !== 0 && lastLocation.kind !== 315 /* SyntaxKind.JSDoc */) {
+                        if ((meaning & result.flags & 788968 /* SymbolFlags.Type */) !== 0 && lastLocation.kind !== 316 /* SyntaxKind.JSDoc */) {
                             useResult =
                                 (result.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0 &&
                                     ((lastLocation.flags & 16 /* NodeFlags.Synthesized */) !== 0 ||
                                         lastLocation === getType(current) ||
-                                        lastLocation.kind === 170 /* SyntaxKind.Parameter */ ||
-                                        lastLocation.kind === 333 /* SyntaxKind.JSDocParameterTag */ ||
-                                        lastLocation.kind === 334 /* SyntaxKind.JSDocReturnTag */ ||
-                                        lastLocation.kind === 169 /* SyntaxKind.TypeParameter */);
+                                        lastLocation.kind === 171 /* SyntaxKind.Parameter */ ||
+                                        lastLocation.kind === 334 /* SyntaxKind.JSDocParameterTag */ ||
+                                        lastLocation.kind === 335 /* SyntaxKind.JSDocReturnTag */ ||
+                                        lastLocation.kind === 170 /* SyntaxKind.TypeParameter */);
                         }
                         if ((meaning & result.flags & 3 /* SymbolFlags.Variable */) !== 0) {
                             if (this.useOuterVariableScopeInParameter(result, current, lastLocation))
@@ -110,7 +117,7 @@ export class NameResolver {
                             else if ((result.flags & 1 /* SymbolFlags.FunctionScopedVariable */) !== 0) {
                                 // Initializers referencing later parameters are checked separately.
                                 useResult =
-                                    lastLocation.kind === 170 /* SyntaxKind.Parameter */ ||
+                                    lastLocation.kind === 171 /* SyntaxKind.Parameter */ ||
                                         (lastLocation.flags & 16 /* NodeFlags.Synthesized */) !== 0 ||
                                         (lastLocation === getType(current) && isInParameter(result.valueDeclaration));
                             }
@@ -127,15 +134,17 @@ export class NameResolver {
             }
             withinDeferredContext = withinDeferredContext || isDeferredContext(current, lastLocation);
             switch (current.kind) {
-                case 307 /* SyntaxKind.SourceFile */:
-                case 268 /* SyntaxKind.ModuleDeclaration */: {
-                    if (current.kind === 307 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(current))
+                case 308 /* SyntaxKind.SourceFile */:
+                case 269 /* SyntaxKind.ModuleDeclaration */: {
+                    if (current.kind === 308 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(current))
+                        break;
+                    if (isModuleAttributes)
                         break;
                     const moduleSymbol = this.getSymbolOfDeclaration(current);
                     if (moduleSymbol === undefined)
                         break;
                     const moduleExports = moduleSymbol.exports ?? emptyTable;
-                    if (current.kind === 307 /* SyntaxKind.SourceFile */ ||
+                    if (current.kind === 308 /* SyntaxKind.SourceFile */ ||
                         ((current.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && !isGlobalScopeAugmentationNode(current))) {
                         // An external module: the local name of its default export is in scope.
                         result = moduleExports.get("default" /* InternalSymbolName.Default */);
@@ -150,14 +159,14 @@ export class NameResolver {
                         const moduleExport = moduleExports.get(name);
                         if (moduleExport !== undefined &&
                             moduleExport.flags === 2097152 /* SymbolFlags.Alias */ &&
-                            (getDeclarationOfKind(moduleExport, 282 /* SyntaxKind.ExportSpecifier */) !== undefined ||
-                                getDeclarationOfKind(moduleExport, 281 /* SyntaxKind.NamespaceExport */) !== undefined))
+                            (getDeclarationOfKind(moduleExport, 283 /* SyntaxKind.ExportSpecifier */) !== undefined ||
+                                getDeclarationOfKind(moduleExport, 282 /* SyntaxKind.NamespaceExport */) !== undefined))
                             break;
                     }
                     if (name !== "default" /* InternalSymbolName.Default */) {
                         result = this.lookup(moduleExports, name, meaning & 2623475 /* SymbolFlags.ModuleMember */);
                         if (result !== undefined) {
-                            if (current.kind === 307 /* SyntaxKind.SourceFile */ &&
+                            if (current.kind === 308 /* SyntaxKind.SourceFile */ &&
                                 current.commonJSModuleIndicator !== undefined &&
                                 (result.flags & 788968 /* SymbolFlags.Type */) === 0)
                                 result = undefined;
@@ -167,7 +176,7 @@ export class NameResolver {
                     }
                     break;
                 }
-                case 267 /* SyntaxKind.EnumDeclaration */: {
+                case 268 /* SyntaxKind.EnumDeclaration */: {
                     const enumSymbol = this.getSymbolOfDeclaration(current);
                     if (enumSymbol === undefined)
                         break;
@@ -185,7 +194,7 @@ export class NameResolver {
                     }
                     break;
                 }
-                case 173 /* SyntaxKind.PropertyDeclaration */:
+                case 174 /* SyntaxKind.PropertyDeclaration */:
                     if (!isStatic(current)) {
                         const ctor = findConstructorDeclaration(current.parent);
                         if (ctor !== undefined) {
@@ -196,9 +205,9 @@ export class NameResolver {
                         }
                     }
                     break;
-                case 264 /* SyntaxKind.ClassDeclaration */:
-                case 232 /* SyntaxKind.ClassExpression */:
-                case 265 /* SyntaxKind.InterfaceDeclaration */: {
+                case 265 /* SyntaxKind.ClassDeclaration */:
+                case 233 /* SyntaxKind.ClassExpression */:
+                case 266 /* SyntaxKind.InterfaceDeclaration */: {
                     const classSymbol = this.getSymbolOfDeclaration(current);
                     result =
                         classSymbol === undefined
@@ -213,12 +222,12 @@ export class NameResolver {
                         // Type parameters aren't in scope in static members.
                         if (lastLocation !== undefined && isStatic(lastLocation)) {
                             if (nameNotFoundMessage !== undefined)
-                                this.error(originalLocation, 480 /* Diagnostics.Static_members_cannot_reference_class_type_parameters */, noArgs);
+                                this.error(originalLocation, 487 /* Diagnostics.Static_members_cannot_reference_class_type_parameters */, noArgs);
                             return undefined;
                         }
                         break loop;
                     }
-                    if (current.kind === 232 /* SyntaxKind.ClassExpression */ && (meaning & 32 /* SymbolFlags.Class */) !== 0) {
+                    if (current.kind === 233 /* SyntaxKind.ClassExpression */ && (meaning & 32 /* SymbolFlags.Class */) !== 0) {
                         const className = getName(current);
                         if (className !== undefined && name === getText(className)) {
                             result = symbolOfNode(current);
@@ -227,7 +236,7 @@ export class NameResolver {
                     }
                     break;
                 }
-                case 234 /* SyntaxKind.ExpressionWithTypeArguments */: {
+                case 235 /* SyntaxKind.ExpressionWithTypeArguments */: {
                     const heritage = current.parent;
                     if (lastLocation === current.expression &&
                         heritage instanceof HeritageClause &&
@@ -241,17 +250,17 @@ export class NameResolver {
                                     : this.lookup(classSymbol.members ?? emptyTable, name, meaning & 788968 /* SymbolFlags.Type */);
                             if (result !== undefined) {
                                 if (nameNotFoundMessage !== undefined)
-                                    this.error(originalLocation, 716 /* Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters */, noArgs);
+                                    this.error(originalLocation, 723 /* Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters */, noArgs);
                                 return undefined;
                             }
                         }
                     }
                     break;
                 }
-                case 168 /* SyntaxKind.ComputedPropertyName */: {
+                case 169 /* SyntaxKind.ComputedPropertyName */: {
                     // A class's computed property names can't reference its own type parameters.
                     const grandparent = current.parent.parent;
-                    if (isClassLike(grandparent) || grandparent.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+                    if (isClassLike(grandparent) || grandparent.kind === 266 /* SyntaxKind.InterfaceDeclaration */) {
                         const containerSymbol = this.getSymbolOfDeclaration(grandparent);
                         result =
                             containerSymbol === undefined
@@ -259,23 +268,23 @@ export class NameResolver {
                                 : this.lookup(containerSymbol.members ?? emptyTable, name, meaning & 788968 /* SymbolFlags.Type */);
                         if (result !== undefined) {
                             if (nameNotFoundMessage !== undefined)
-                                this.error(originalLocation, 633 /* Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type */, noArgs);
+                                this.error(originalLocation, 640 /* Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type */, noArgs);
                             return undefined;
                         }
                     }
                     break;
                 }
-                case 175 /* SyntaxKind.MethodDeclaration */:
-                case 177 /* SyntaxKind.Constructor */:
-                case 178 /* SyntaxKind.GetAccessor */:
-                case 179 /* SyntaxKind.SetAccessor */:
-                case 263 /* SyntaxKind.FunctionDeclaration */:
+                case 176 /* SyntaxKind.MethodDeclaration */:
+                case 178 /* SyntaxKind.Constructor */:
+                case 179 /* SyntaxKind.GetAccessor */:
+                case 180 /* SyntaxKind.SetAccessor */:
+                case 264 /* SyntaxKind.FunctionDeclaration */:
                     if ((meaning & 3 /* SymbolFlags.Variable */) !== 0 && name === 'arguments') {
                         result = this.getArgumentsSymbol();
                         break loop;
                     }
                     break;
-                case 219 /* SyntaxKind.FunctionExpression */: {
+                case 220 /* SyntaxKind.FunctionExpression */: {
                     if ((meaning & 3 /* SymbolFlags.Variable */) !== 0 && name === 'arguments') {
                         result = this.getArgumentsSymbol();
                         break loop;
@@ -287,18 +296,18 @@ export class NameResolver {
                     }
                     break;
                 }
-                case 171 /* SyntaxKind.Decorator */: {
+                case 172 /* SyntaxKind.Decorator */: {
                     // Decorators resolve at the class: a parameter's at its class member, a member's at the class.
                     let parent = current.parent;
-                    if (parent !== undefined && parent.kind === 170 /* SyntaxKind.Parameter */) {
+                    if (parent !== undefined && parent.kind === 171 /* SyntaxKind.Parameter */) {
                         current = parent;
                         parent = current.parent;
                     }
-                    if (parent !== undefined && (isClassElement(parent) || parent.kind === 264 /* SyntaxKind.ClassDeclaration */))
+                    if (parent !== undefined && (isClassElement(parent) || parent.kind === 265 /* SyntaxKind.ClassDeclaration */))
                         current = parent;
                     break;
                 }
-                case 170 /* SyntaxKind.Parameter */: {
+                case 171 /* SyntaxKind.Parameter */: {
                     const parameter = current;
                     if (lastLocation !== undefined &&
                         (lastLocation === parameter.initializer ||
@@ -307,7 +316,7 @@ export class NameResolver {
                         associatedDeclarationForContainingInitializerOrBindingName = current;
                     break;
                 }
-                case 209 /* SyntaxKind.BindingElement */: {
+                case 210 /* SyntaxKind.BindingElement */: {
                     const element = current;
                     if (lastLocation !== undefined &&
                         (lastLocation === element.initializer ||
@@ -317,7 +326,7 @@ export class NameResolver {
                         associatedDeclarationForContainingInitializerOrBindingName = current;
                     break;
                 }
-                case 196 /* SyntaxKind.InferType */:
+                case 197 /* SyntaxKind.InferType */:
                     if ((meaning & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
                         const typeParameter = current.typeParameter;
                         if (name === typeParameter.name.text) {
@@ -326,7 +335,7 @@ export class NameResolver {
                         }
                     }
                     break;
-                case 282 /* SyntaxKind.ExportSpecifier */: {
+                case 283 /* SyntaxKind.ExportSpecifier */: {
                     // `export { a as b } from "m"`: `a` resolves outside this module.
                     const specifier = current;
                     const exportDeclaration = current.parent.parent;
@@ -371,7 +380,7 @@ export class NameResolver {
      * aren't in scope there unless emit moves the parameter into the body.
      */
     useOuterVariableScopeInParameter(result, location, lastLocation) {
-        if (lastLocation.kind !== 170 /* SyntaxKind.Parameter */)
+        if (lastLocation.kind !== 171 /* SyntaxKind.Parameter */)
             return false;
         const body = getBody(location);
         const declaration = result.valueDeclaration;
@@ -407,17 +416,17 @@ class ScopeChangeFinder extends NodeVisitor {
     }
     requiresScopeChange(node) {
         switch (node.kind) {
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 177 /* SyntaxKind.Constructor */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 178 /* SyntaxKind.Constructor */:
                 return false;
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
                 return this.requiresScopeChange(getName(node));
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (hasStaticModifier(node))
                     return !getEmitStandardClassFields(this.options);
                 return this.requiresScopeChange(getName(node));
@@ -426,7 +435,7 @@ class ScopeChangeFinder extends NodeVisitor {
             return getEmitScriptTarget(this.options) < 7 /* ScriptTarget.ES2020 */;
         if (node instanceof BindingElement &&
             node.dotDotDotToken !== undefined &&
-            node.parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+            node.parent.kind === 208 /* SyntaxKind.ObjectBindingPattern */)
             return getEmitScriptTarget(this.options) < 4 /* ScriptTarget.ES2017 */;
         if (isTypeNodeKind(node.kind))
             return false;
@@ -446,14 +455,14 @@ function getLocalsOf(node) {
     return getLocals(node);
 }
 function isBindingPattern(node) {
-    return node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */;
+    return node.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 209 /* SyntaxKind.ArrayBindingPattern */;
 }
 function isGlobalScopeAugmentationNode(node) {
     return node instanceof ModuleDeclaration && node.keyword === 162 /* SyntaxKind.GlobalKeyword */;
 }
 function isInParameter(declaration) {
     for (let current = declaration; current !== undefined; current = current.parent)
-        if (current.kind === 170 /* SyntaxKind.Parameter */)
+        if (current.kind === 171 /* SyntaxKind.Parameter */)
             return true;
     return false;
 }
@@ -471,11 +480,11 @@ export function getLocalSymbolForExportDefault(symbol) {
 }
 /** Whether a reference at `location` runs later than its scope's own code, like in a function body. */
 function isDeferredContext(location, lastLocation) {
-    if (location.kind !== 220 /* SyntaxKind.ArrowFunction */ && location.kind !== 219 /* SyntaxKind.FunctionExpression */) {
+    if (location.kind !== 221 /* SyntaxKind.ArrowFunction */ && location.kind !== 220 /* SyntaxKind.FunctionExpression */) {
         // Instance property initializers run in the constructor; a declaration's name runs in its scope.
-        return (location.kind === 187 /* SyntaxKind.TypeQuery */ ||
+        return (location.kind === 188 /* SyntaxKind.TypeQuery */ ||
             ((isFunctionLikeDeclarationKind(location.kind) ||
-                (location.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !isStatic(location))) &&
+                (location.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !isStatic(location))) &&
                 (lastLocation === undefined || lastLocation !== getName(location))));
     }
     if (lastLocation !== undefined && lastLocation === getName(location))
@@ -487,21 +496,21 @@ function isDeferredContext(location, lastLocation) {
 }
 function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
     for (const declaration of getDeclarations(symbol))
-        if (declaration.kind === 169 /* SyntaxKind.TypeParameter */ && declaration.parent === container)
+        if (declaration.kind === 170 /* SyntaxKind.TypeParameter */ && declaration.parent === container)
             return true;
     return false;
 }
 function isSelfReferenceLocation(node, lastLocation) {
     switch (node.kind) {
-        case 170 /* SyntaxKind.Parameter */:
+        case 171 /* SyntaxKind.Parameter */:
             return lastLocation !== undefined && lastLocation === getName(node);
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
             // `namespace N { N; }`
             return true;
     }

package/dist/api/compiler/node-builder-names.d.ts

@@ -1,4 +1,5 @@
 import { type Node, type NodeList, SourceFile } from './ast.js';
+import { type Type } from './checker-types.js';
 import type { Checker } from './checker.js';
 import { ModuleSpecifierPreferences } from './module-specifiers.js';
 import { ModuleKind } from './options.js';
@@ -21,12 +22,19 @@ export declare function symbolToExpression(b: NodeBuilder, symbol: Symbol, meani
  */
 export declare function getNameOfSymbolAsWritten(b: NodeBuilder, symbol: Symbol): string;
 /** The name node of a property. */
-export declare function getPropertyNameNodeForSymbol(b: NodeBuilder, symbol: Symbol): Node;
+export declare function getPropertyNameNodeForSymbol(b: NodeBuilder, symbol: Symbol, enclosingDeclaration: Node | undefined): Node;
+/** A module specifier, and the import attributes type an `import()` type with it needs. */
+export declare class ModuleSpecifierResult {
+    readonly specifier: string;
+    readonly importAttributesType: Type | undefined;
+    constructor(specifier: string, importAttributesType: Type | undefined);
+}
 /**
  * The specifier an `import("…")` type names a module with: an ambient module's name, the file
  * name without an enclosing file, else what module specifier generation gives for the enclosing
- * file. `overrideImportMode` is `None` for the mode of the enclosing import or file.
+ * file. `overrideImportMode` is `None` for the mode of the enclosing import or file. A pattern
+ * ambient module's specifier comes with the attributes type that resolves it.
  */
-export declare function getSpecifierForModuleSymbol(b: NodeBuilder, symbol: Symbol, overrideImportMode: ModuleKind): string;
+export declare function getSpecifierForModuleSymbol(b: NodeBuilder, symbol: Symbol, overrideImportMode: ModuleKind): ModuleSpecifierResult;
 /** Specifiers `importingFile` can import the module `moduleSymbol` with, best first. */
 export declare function getModuleSpecifiers(c: Checker, moduleSymbol: Symbol, importingFile: SourceFile, preferences: ModuleSpecifierPreferences, overrideImportMode: ModuleKind): string[];