tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/node-builder-names.js

@@ -2,24 +2,31 @@
 // declaration, written as an entity name, `import("…")` type, indexed access or expression.
 import { ComputedPropertyName, ElementAccessExpression, ExpressionWithTypeArguments, ImportAttribute, ImportAttributes, ImportTypeNode, IndexedAccessTypeNode, LiteralTypeNode, ParenthesizedTypeNode, PrefixUnaryExpression, PropertyAccessExpression, QualifiedName, SourceFile, StringLiteral, TypeQueryNode, TypeReferenceNode, getArguments, getExpression, getInitializer, getModuleSpecifier, getName, getSymbol, getText, } from './ast.js';
 import { declarationNameToString, getDeclarationOfKind, getNameOfDeclaration, getSourceFileOfNode, isModuleAugmentationExternal, } from './binder-utilities.js';
-import { getExternalModuleName, isAmbientModule, isGlobalScopeAugmentation, isRequireCall } from './ast-utilities.js';
+import { getExternalModuleName, isAmbientModule, isGlobalScopeAugmentation, isImportCall, isRequireCall, } from './ast-utilities.js';
 import { getSymbolAtLocation } from './checker-services.js';
 import { checkExpression } from './checker-expressions.js';
-import { getExportsOfSymbol, getMembersOfSymbol, isAmbientModuleSymbolName, resolveAlias } from './checker-symbols.js';
-import { compareSymbols } from './checker-type-factory.js';
+import { getExportsOfSymbol, getMembersOfSymbol, getMergedSymbol, resolveAlias } from './checker-symbols.js';
+import { getImportAttributesTypeForModuleSpecifier, getTypeOfModuleImportAttributes, resolveExternalModule, } from './checker-modules.js';
+import { getPropertiesOfType } from './checker-members.js';
+import { getTypeOfSymbol } from './checker-symbol-types.js';
+import { compareSymbols, isEmptyObjectType } from './checker-type-factory.js';
 import { isLateBoundName } from './checker-utilities.js';
 import { isExternalModuleNameRelative, pathIsRelative } from './path.js';
 import { ModuleSpecifierHost, ModuleSpecifierPreferences, countPathComponents, getModuleSpecifiersForFile, } from './module-specifiers.js';
 import { ModuleKind, ModuleResolutionKind, getModuleResolutionKind } from './options.js';
 import { isExternalModuleAugmentation } from './transformers/declarations-syntactic.js';
 import { isIdentifierText } from './scanner.js';
-import { getAccessibleSymbolChain, getAliasForSymbolInContainer, getContainersOfSymbol, getFileSymbolIfFileSymbolExportEqualsContainer, getQualifiedLeftMeaning, getSymbolIfSameReference, hasNonGlobalAugmentationExternalModuleDeclaration, needsQualification, } from './symbol-accessibility.js';
+import { getAccessibleSymbolChain, getAliasForSymbolInContainer, getContainersOfSymbol, getFileSymbolIfFileSymbolExportEqualsContainer, getQualifiedLeftMeaning, getSymbolIfSameReference, hasNonGlobalAugmentationExternalModuleDeclaration, isSymbolAccessibleByFlags, needsQualification, } from './symbol-accessibility.js';
 import { classifyPropertyName, isNumericLiteralName } from './node-builder.js';
-import { declarationCount, escapeInternalSymbolName, getDeclarations, getSymbolId, } from './symbol.js';
+import { declarationCount, escapeInternalSymbolName, getDeclarations, getSymbolId, tryGetAmbientModuleNameFromSymbolName, } from './symbol.js';
 // ---- Symbol chains
 /** The chain of symbols naming `symbol`, reported to the tracker. */
 export function lookupSymbolChain(b, symbol, meaning, yieldModuleSymbol) {
     b.trackSymbol(symbol, b.enclosingDeclaration, meaning);
+    return lookupSymbolChainWorker(b, symbol, meaning, yieldModuleSymbol);
+}
+/** `lookupSymbolChain` without tracking the symbol's accessibility. */
+function lookupSymbolChainWorker(b, symbol, meaning, yieldModuleSymbol) {
     // Qualified only with somewhere to qualify from, and never for type parameters.
     if ((symbol.flags & 262144 /* SymbolFlags.TypeParameter */) === 0 &&
         (b.enclosingDeclaration !== undefined || (b.flags & 64 /* NodeBuilderFlags.UseFullyQualifiedType */) !== 0) &&
@@ -42,7 +49,7 @@ function getSymbolChain(b, symbol, meaning, endOfChain, yieldModuleSymbol) {
             for (const p of parents) {
                 order.push(specifiers.length);
                 specifiers.push(hasNonGlobalAugmentationExternalModuleDeclaration(p)
-                    ? getSpecifierForModuleSymbol(b, p, ModuleKind.None)
+                    ? getSpecifierForModuleSymbol(b, p, ModuleKind.None).specifier
                     : '');
             }
             order.sort((x, y) => compareByBestName(b, parents[x], specifiers[x], parents[y], specifiers[y]) || x - y);
@@ -95,8 +102,8 @@ export function symbolToTypeNode(b, symbol, mask, typeArguments) {
         // A module root needs an `import` type.
         const nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(b, chain, chain.length - 1, 1, typeArguments) : undefined;
         const typeParameterNodes = typeArguments ?? lookupTypeParameterNodes(b, chain, 0);
-        let specifier = '';
-        let attributes = undefined;
+        let specifier = new ModuleSpecifierResult('', undefined);
+        let importModeOverride = ModuleKind.None;
         const c = b.c;
         const resolution = getModuleResolutionKind(c.compilerOptions);
         const nodeNext = resolution === ModuleResolutionKind.Node16 || resolution === ModuleResolutionKind.NodeNext;
@@ -110,31 +117,33 @@ export function symbolToTypeNode(b, symbol, mask, typeArguments) {
                 const targetFormat = c.host.getEmitModuleFormatOfFile(targetFile);
                 if (targetFormat === ModuleKind.ESNext && targetFormat !== c.host.getEmitModuleFormatOfFile(contextFile)) {
                     specifier = getSpecifierForModuleSymbol(b, chain[0], ModuleKind.ESNext);
-                    attributes = resolutionModeAttributes(b, 'import');
+                    importModeOverride = ModuleKind.ESNext;
                 }
             }
         }
-        if (specifier === '')
+        if (specifier.specifier === '')
             specifier = getSpecifierForModuleSymbol(b, chain[0], ModuleKind.None);
-        if ((b.flags & 67108864 /* NodeBuilderFlags.AllowNodeModulesRelativePaths */) === 0 && specifier.includes('/node_modules/')) {
+        if ((b.flags & 67108864 /* NodeBuilderFlags.AllowNodeModulesRelativePaths */) === 0 &&
+            specifier.specifier.includes('/node_modules/')) {
             const oldSpecifier = specifier;
             if (nodeNext && contextFile !== undefined) {
                 // The other mode may reach the module portably.
                 const swappedMode = c.host.getEmitModuleFormatOfFile(contextFile) === ModuleKind.ESNext ? ModuleKind.CommonJS : ModuleKind.ESNext;
                 specifier = getSpecifierForModuleSymbol(b, chain[0], swappedMode);
-                if (specifier.includes('/node_modules/'))
+                if (specifier.specifier.includes('/node_modules/'))
                     specifier = oldSpecifier;
                 else
-                    attributes = resolutionModeAttributes(b, swappedMode === ModuleKind.ESNext ? 'import' : 'require');
+                    importModeOverride = swappedMode;
             }
-            if (attributes === undefined) {
+            if (importModeOverride === ModuleKind.None) {
                 // A reference into `node_modules` is likely to break when published.
                 b.encounteredError = true;
-                b.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier, symbol.name);
+                b.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier.specifier, symbol.name);
             }
         }
-        const literal = b.created(new LiteralTypeNode(b.stringLiteral(specifier, false)));
-        b.approximateLength += specifier.length + 10;
+        const attributes = createImportAttributesForModuleSpecifier(b, specifier, importModeOverride);
+        const literal = b.created(new LiteralTypeNode(b.stringLiteral(specifier.specifier, false)));
+        b.approximateLength += specifier.specifier.length + 10;
         if (nonRootParts === undefined || isEntityName(nonRootParts))
             return b.created(new ImportTypeNode(isTypeOf, literal, attributes, nonRootParts, typeParameterNodes));
         const splitNode = getTopmostIndexedAccessType(nonRootParts);
@@ -154,12 +163,48 @@ export function symbolToTypeNode(b, symbol, mask, typeArguments) {
     return entityName;
 }
 function isEntityName(node) {
-    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 168 /* SyntaxKind.QualifiedName */;
 }
-/** `with { "resolution-mode": "import" }` or `"require"`. */
-function resolutionModeAttributes(b, mode) {
-    const attribute = b.created(new ImportAttribute(b.stringLiteral('resolution-mode', false), b.stringLiteral(mode, false)));
-    return b.created(new ImportAttributes(117 /* SyntaxKind.WithKeyword */, b.list([attribute]), false));
+/**
+ * The attributes of an `import()` type: a `resolution-mode` for `importModeOverride`, then the
+ * string literal properties of the specifier's import attributes type, by name.
+ */
+function createImportAttributesForModuleSpecifier(b, result, importModeOverride) {
+    const c = b.c;
+    const attributesType = result.importAttributesType;
+    const isEmptyAttributesType = attributesType === undefined || isEmptyObjectType(c, attributesType);
+    if (isEmptyAttributesType && importModeOverride === ModuleKind.None)
+        return undefined;
+    const attributes = [];
+    if (importModeOverride !== ModuleKind.None) {
+        const mode = importModeOverride === ModuleKind.ESNext ? 'import' : 'require';
+        attributes.push(b.created(new ImportAttribute(b.stringLiteral('resolution-mode', false), b.stringLiteral(mode, false))));
+        b.approximateLength += 'resolution-mode'.length + mode.length + 6;
+    }
+    if (!isEmptyAttributesType) {
+        const properties = getPropertiesOfType(c, attributesType).slice();
+        properties.sort((x, y) => (x.name < y.name ? -1 : x.name > y.name ? 1 : 0));
+        for (const property of properties) {
+            const name = property.name;
+            const propertyType = getTypeOfSymbol(c, property);
+            if ((propertyType.flags & 1024 /* TypeFlags.StringLiteral */) === 0)
+                continue;
+            const value = propertyType.stringValue;
+            let nameNode;
+            if (isIdentifierText(name))
+                nameNode = b.factory.createIdentifier(name);
+            else {
+                nameNode = b.stringLiteral(name, false);
+                b.approximateLength += 2;
+            }
+            attributes.push(b.created(new ImportAttribute(nameNode, b.stringLiteral(value, false))));
+            b.approximateLength += name.length + value.length + 4;
+        }
+    }
+    if (attributes.length === 0)
+        return undefined;
+    b.approximateLength += 16 + 2 * (attributes.length - 1);
+    return b.created(new ImportAttributes(117 /* SyntaxKind.WithKeyword */, b.list(attributes), false));
 }
 function getTopmostIndexedAccessType(node) {
     const objectType = node.objectType;
@@ -212,7 +257,7 @@ function createAccessFromSymbolChain(b, chain, index, stopper, overrideTypeArgum
             if (name !== undefined)
                 break;
         }
-        if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && isEntityName(getExpression(name))) {
+        if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && isEntityName(getExpression(name))) {
             const lhs = createAccessFromSymbolChain(b, chain, index - 1, stopper, overrideTypeArguments);
             if (isEntityName(lhs))
                 return b.created(new IndexedAccessTypeNode(b.created(new ParenthesizedTypeNode(b.created(new TypeQueryNode(lhs, undefined)))), b.created(new TypeQueryNode(getExpression(name), undefined))));
@@ -232,7 +277,7 @@ function createAccessFromSymbolChain(b, chain, index, stopper, overrideTypeArgum
             return b.created(new IndexedAccessTypeNode(b.created(new TypeReferenceNode(lhs, typeParameterNodes)), literal));
         }
     }
-    const identifier = b.identifier(symbolName);
+    const identifier = b.symbolIdentifier(symbolName, symbol);
     b.context.addEmitFlags(identifier, 131072 /* EmitFlags.NoAsciiEscaping */);
     if (index > stopper) {
         const lhs = createAccessFromSymbolChain(b, chain, index - 1, stopper, overrideTypeArguments);
@@ -316,7 +361,7 @@ function createEntityNameFromSymbolChain(b, chain, index) {
     const symbolName = getNameOfSymbolAsWritten(b, symbol);
     if (index === 0)
         b.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
-    const identifier = b.identifier(symbolName);
+    const identifier = b.symbolIdentifier(symbolName, symbol);
     b.context.addEmitFlags(identifier, 131072 /* EmitFlags.NoAsciiEscaping */);
     if (index > 0)
         return b.created(new QualifiedName(createEntityNameFromSymbolChain(b, chain, index - 1), identifier));
@@ -330,7 +375,12 @@ export function symbolToEntityNameNode(b, symbol) {
     return identifier;
 }
 export function symbolToExpression(b, symbol, meaning) {
-    const chain = lookupSymbolChain(b, symbol, meaning, false);
+    b.trackSymbol(symbol, b.enclosingDeclaration, meaning);
+    return symbolToExpressionWorker(b, symbol, meaning);
+}
+/** `symbolToExpression` without tracking the symbol's accessibility. */
+function symbolToExpressionWorker(b, symbol, meaning) {
+    const chain = lookupSymbolChainWorker(b, symbol, meaning, false);
     return createExpressionFromSymbolChain(b, chain, chain.length - 1);
 }
 function createExpressionFromSymbolChain(b, chain, index) {
@@ -342,7 +392,7 @@ function createExpressionFromSymbolChain(b, chain, index) {
     if (index === 0)
         b.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
     if (startsWithQuote(symbolName) && hasNonGlobalAugmentationExternalModuleDeclaration(symbol)) {
-        const specifier = getSpecifierForModuleSymbol(b, symbol, ModuleKind.None);
+        const specifier = getSpecifierForModuleSymbol(b, symbol, ModuleKind.None).specifier;
         b.approximateLength += 2 + specifier.length;
         return b.stringLiteral(specifier, false);
     }
@@ -449,7 +499,7 @@ function lookupExpressionChainTypeArgumentNodes(b, chain, index) {
 }
 // ---- Names as written
 function isDefaultBindingContext(node) {
-    return node.kind === 307 /* SyntaxKind.SourceFile */ || isAmbientModule(node);
+    return node.kind === 308 /* SyntaxKind.SourceFile */ || isAmbientModule(node);
 }
 function findDefaultBindingContext(node) {
     for (let current = node; current !== undefined; current = current.parent)
@@ -502,7 +552,7 @@ export function getNameOfSymbolAsWritten(b, symbol) {
                 break;
         }
         if (name !== undefined) {
-            if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && (symbol.checkFlags & 4096 /* CheckFlags.Late */) === 0) {
+            if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && (symbol.checkFlags & 32768 /* CheckFlags.Late */) === 0) {
                 const nameType = b.c.symbolNameTypes.get(getSymbolId(symbol));
                 if (nameType !== undefined && (nameType.flags & 3072 /* TypeFlags.StringOrNumberLiteral */) !== 0) {
                     const result = getNameOfSymbolFromNameType(b, symbol);
@@ -514,17 +564,17 @@ export function getNameOfSymbolAsWritten(b, symbol) {
         }
         const declaration = symbol.declaration;
         const parent = declaration.parent;
-        if (parent !== undefined && parent.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+        if (parent !== undefined && parent.kind === 262 /* SyntaxKind.VariableDeclaration */) {
             const parentName = getName(parent);
             return declarationNameToString(getSourceFileOfNode(parentName), parentName);
         }
         switch (declaration.kind) {
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (!b.encounteredError && (b.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) === 0)
                     b.encounteredError = true;
-                return declaration.kind === 232 /* SyntaxKind.ClassExpression */ ? '(Anonymous class)' : '(Anonymous function)';
+                return declaration.kind === 233 /* SyntaxKind.ClassExpression */ ? '(Anonymous class)' : '(Anonymous function)';
         }
     }
     const name = getNameOfSymbolFromNameType(b, symbol);
@@ -548,7 +598,7 @@ function isSingleQuotedStringNamed(d) {
     return name instanceof StringLiteral && (name.tokenFlags & 65536 /* TokenFlags.SingleQuote */) !== 0;
 }
 /** The name node of a property. */
-export function getPropertyNameNodeForSymbol(b, symbol) {
+export function getPropertyNameNodeForSymbol(b, symbol, enclosingDeclaration) {
     // A private name is the declaration's.
     const valueDeclaration = symbol.valueDeclaration;
     if (valueDeclaration !== undefined) {
@@ -570,7 +620,7 @@ export function getPropertyNameNodeForSymbol(b, symbol) {
             break;
         }
     const isMethod = (symbol.flags & 8192 /* SymbolFlags.Method */) !== 0;
-    const fromNameType = getPropertyNameNodeForSymbolFromNameType(b, symbol, singleQuote, stringNamed, isMethod);
+    const fromNameType = getPropertyNameNodeForSymbolFromNameType(b, symbol, enclosingDeclaration, singleQuote, stringNamed, isMethod);
     if (fromNameType !== undefined)
         return fromNameType;
     let name = symbol.name;
@@ -595,10 +645,23 @@ function createPropertyNameNodeForIdentifierOrLiteral(b, name, singleQuote, stri
     }
     return b.factory.createStringLiteral(name, singleQuote ? 65536 /* TokenFlags.SingleQuote */ : 0 /* TokenFlags.None */);
 }
-function getPropertyNameNodeForSymbolFromNameType(b, symbol, singleQuote, stringNamed, isMethod) {
+function getPropertyNameNodeForSymbolFromNameType(b, symbol, enclosingDeclaration, singleQuote, stringNamed, isMethod) {
     const nameType = b.c.symbolNameTypes.get(getSymbolId(symbol));
     if (nameType === undefined)
         return undefined;
+    // A name from an enum member stays a computed name, `[E.A]`, where the enum can be named.
+    if ((nameType.flags & 32768 /* TypeFlags.EnumLiteral */) !== 0) {
+        const enumEnclosingDeclaration = enclosingDeclaration !== undefined ? enclosingDeclaration : b.enclosingFile;
+        const enumSymbol = nameType.symbol.parent !== undefined ? nameType.symbol.parent : nameType.symbol;
+        if (enumEnclosingDeclaration !== undefined &&
+            isSymbolAccessibleByFlags(b.c, enumSymbol, enumEnclosingDeclaration, 111551 /* SymbolFlags.Value */)) {
+            const saveEnclosingDeclaration = b.enclosingDeclaration;
+            b.enclosingDeclaration = enumEnclosingDeclaration;
+            const result = b.created(new ComputedPropertyName(symbolToExpression(b, nameType.symbol, 111551 /* SymbolFlags.Value */)));
+            b.enclosingDeclaration = saveEnclosingDeclaration;
+            return result;
+        }
+    }
     if ((nameType.flags & 3072 /* TypeFlags.StringOrNumberLiteral */) !== 0) {
         const literal = nameType;
         const name = (nameType.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 ? literal.stringValue : String(literal.numberValue);
@@ -608,40 +671,66 @@ function getPropertyNameNodeForSymbolFromNameType(b, symbol, singleQuote, string
             return b.created(new ComputedPropertyName(b.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, b.factory.createNumericLiteral(name.substring(1))))));
         return createPropertyNameNodeForIdentifierOrLiteral(b, name, singleQuote, stringNamed, isMethod);
     }
+    // The reference is tracked where the name is used; spelling it here must not track it in this scope.
     if ((nameType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
-        return b.created(new ComputedPropertyName(symbolToExpression(b, nameType.symbol, 111551 /* SymbolFlags.Value */)));
+        return b.created(new ComputedPropertyName(symbolToExpressionWorker(b, nameType.symbol, 111551 /* SymbolFlags.Value */)));
     return undefined;
 }
 // ---- Module specifiers
+/** A module specifier, and the import attributes type an `import()` type with it needs. */
+export class ModuleSpecifierResult {
+    specifier;
+    importAttributesType;
+    constructor(specifier, importAttributesType) {
+        this.specifier = specifier;
+        this.importAttributesType = importAttributesType;
+    }
+}
 /**
  * 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 function getSpecifierForModuleSymbol(b, symbol, overrideImportMode) {
     const c = b.c;
-    let file = asSourceFile(getDeclarationOfKind(symbol, 307 /* SyntaxKind.SourceFile */));
+    const enclosingDeclaration = b.enclosingDeclaration === undefined ? undefined : b.context.mostOriginal(b.enclosingDeclaration);
+    const originalModuleSpecifier = enclosingDeclaration !== undefined && canHaveModuleSpecifier(enclosingDeclaration)
+        ? tryGetModuleSpecifierFromDeclaration(enclosingDeclaration)
+        : undefined;
+    const originalImportAttributesType = originalModuleSpecifier !== undefined
+        ? getImportAttributesTypeForModuleSpecifier(c, originalModuleSpecifier)
+        : undefined;
+    let file = asSourceFile(getDeclarationOfKind(symbol, 308 /* SyntaxKind.SourceFile */));
     if (file === undefined)
         for (const d of getDeclarations(symbol)) {
             const equivalent = getFileSymbolIfFileSymbolExportEqualsContainer(c, d, symbol);
             if (equivalent !== undefined) {
-                file = asSourceFile(getDeclarationOfKind(equivalent, 307 /* SyntaxKind.SourceFile */));
+                file = asSourceFile(getDeclarationOfKind(equivalent, 308 /* SyntaxKind.SourceFile */));
                 break;
             }
         }
-    if (file === undefined && isAmbientModuleSymbolName(symbol.name))
-        return symbol.name.substring(1, symbol.name.length - 1);
+    if (file === undefined) {
+        for (const declaration of getDeclarations(symbol))
+            if (isModuleWithStringLiteralName(declaration)) {
+                const specifier = getText(getName(declaration));
+                if (originalImportAttributesType !== undefined &&
+                    moduleSpecifierResolvesToSymbol(b, specifier, originalImportAttributesType, symbol))
+                    return new ModuleSpecifierResult(specifier, originalImportAttributesType);
+                return new ModuleSpecifierResult(specifier, getTypeOfModuleImportAttributes(c, symbol));
+            }
+        const ambientName = tryGetAmbientModuleNameFromSymbolName(symbol.name);
+        if (ambientName !== undefined)
+            return new ModuleSpecifierResult(ambientName, undefined);
+    }
     const contextFile = b.enclosingFile;
     if (contextFile === undefined) {
-        if (isAmbientModuleSymbolName(symbol.name))
-            return symbol.name.substring(1, symbol.name.length - 1);
+        const ambientName = tryGetAmbientModuleNameFromSymbolName(symbol.name);
+        if (ambientName !== undefined)
+            return new ModuleSpecifierResult(ambientName, undefined);
         const moduleFile = getSourceFileOfModule(symbol);
-        return moduleFile === undefined ? '' : moduleFile.fileName;
+        return new ModuleSpecifierResult(moduleFile === undefined ? '' : moduleFile.fileName, undefined);
     }
-    const enclosingDeclaration = b.enclosingDeclaration === undefined ? undefined : b.context.mostOriginal(b.enclosingDeclaration);
-    const originalModuleSpecifier = enclosingDeclaration !== undefined && canHaveModuleSpecifier(enclosingDeclaration)
-        ? tryGetModuleSpecifierFromDeclaration(enclosingDeclaration)
-        : undefined;
     let resolutionMode = overrideImportMode;
     if (resolutionMode === ModuleKind.None)
         resolutionMode =
@@ -651,25 +740,56 @@ export function getSpecifierForModuleSymbol(b, symbol, overrideImportMode) {
     const key = getSymbolId(symbol) + '|' + contextFile.path + '|' + resolutionMode;
     const cached = c.moduleSpecifiers.get(key);
     if (cached !== undefined)
-        return cached;
+        return moduleSpecifierResultForSymbol(b, cached, originalImportAttributesType, symbol);
     // Declaration emit prefers project-relative specifiers, with `.js` extensions in ES modules.
     const preferences = new ModuleSpecifierPreferences('project-relative', resolutionMode === ModuleKind.ESNext ? 'js' : '');
-    const specifiers = getModuleSpecifiers(c, symbol, contextFile, preferences, overrideImportMode);
-    const specifier = specifiers.length > 0 ? specifiers[0] : '';
-    c.moduleSpecifiers.set(key, specifier);
-    return specifier;
+    const specifiers = getModuleSpecifiersWithAmbientModule(c, symbol, contextFile, preferences, overrideImportMode);
+    const result = new ModuleSpecifierResult(specifiers.specifiers.length > 0 ? specifiers.specifiers[0] : '', specifiers.ambientModuleSymbol !== undefined
+        ? getTypeOfModuleImportAttributes(c, specifiers.ambientModuleSymbol)
+        : undefined);
+    c.moduleSpecifiers.set(key, result);
+    return moduleSpecifierResultForSymbol(b, result, originalImportAttributesType, symbol);
+}
+/** `result` with `importAttributesType`, if its specifier resolves to `symbol` with those attributes. */
+function moduleSpecifierResultForSymbol(b, result, importAttributesType, symbol) {
+    if (importAttributesType !== undefined &&
+        moduleSpecifierResolvesToSymbol(b, result.specifier, importAttributesType, symbol))
+        return new ModuleSpecifierResult(result.specifier, importAttributesType);
+    return result;
+}
+function moduleSpecifierResolvesToSymbol(b, specifier, importAttributesType, symbol) {
+    const location = b.enclosingDeclaration ?? b.enclosingFile;
+    if (location === undefined)
+        return false;
+    const c = b.c;
+    const resolved = resolveExternalModule(c, location, specifier, undefined, undefined, false, importAttributesType);
+    return resolved !== undefined && getMergedSymbol(c, resolved) === getMergedSymbol(c, symbol);
+}
+/** The specifiers of `getModuleSpecifiers`, and the ambient module symbol that gives an ambient module's name. */
+class ModuleSpecifiers {
+    specifiers;
+    ambientModuleSymbol;
+    constructor(specifiers, ambientModuleSymbol) {
+        this.specifiers = specifiers;
+        this.ambientModuleSymbol = ambientModuleSymbol;
+    }
 }
 /** Specifiers `importingFile` can import the module `moduleSymbol` with, best first. */
 export function getModuleSpecifiers(c, moduleSymbol, importingFile, preferences, overrideImportMode) {
+    return getModuleSpecifiersWithAmbientModule(c, moduleSymbol, importingFile, preferences, overrideImportMode)
+        .specifiers;
+}
+function getModuleSpecifiersWithAmbientModule(c, moduleSymbol, importingFile, preferences, overrideImportMode) {
     const ambient = tryGetModuleNameFromAmbientModule(c, moduleSymbol);
-    if (ambient !== '')
-        return [ambient];
+    if (ambient !== undefined)
+        return new ModuleSpecifiers([getText(getName(ambient))], getSymbol(ambient));
     const moduleFile = getSourceFileOfModule(moduleSymbol);
     if (moduleFile === undefined)
-        return [];
+        return new ModuleSpecifiers([], undefined);
     const host = getModuleSpecifierHost(c);
     // A referenced project's declaration output is named by its source.
-    return getModuleSpecifiersForFile(importingFile, host.getSourceOfProjectReferenceIfOutputIncluded(moduleFile), c.compilerOptions, host, preferences, overrideImportMode, false);
+    const specifiers = getModuleSpecifiersForFile(importingFile, host.getSourceOfProjectReferenceIfOutputIncluded(moduleFile), c.compilerOptions, host, preferences, overrideImportMode, false);
+    return new ModuleSpecifiers(specifiers, undefined);
 }
 function getModuleSpecifierHost(c) {
     let host = c.host.getModuleSpecifierHost();
@@ -682,26 +802,26 @@ function getModuleSpecifierHost(c) {
     }
     return host;
 }
-/** The name of an ambient module declaring `moduleSymbol`, or of the one whose `export =` it is, else `''`. */
+/** The ambient module declaring `moduleSymbol`, or the one whose `export =` it is. */
 function tryGetModuleNameFromAmbientModule(c, moduleSymbol) {
     for (const d of getDeclarations(moduleSymbol)) {
         const name = isModuleWithStringLiteralName(d) ? getName(d) : undefined;
         if (name !== undefined && (!isModuleAugmentationExternal(d) || !isExternalModuleNameRelative(getText(name))))
-            return getText(name);
+            return d;
     }
     // A namespace exported with `export =` from an ambient module: `import { c } from "m"` names
     // `ns.c` for `declare module "m" { namespace ns { class c {} } export = ns; }`.
     for (const d of getDeclarations(moduleSymbol)) {
-        if (d.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
+        if (d.kind !== 269 /* SyntaxKind.ModuleDeclaration */)
             continue;
         let container = d;
         while (container !== undefined && !isModuleWithStringLiteralName(container))
             container = container.parent;
-        if (container === undefined || container.parent === undefined || container.parent.kind !== 307 /* SyntaxKind.SourceFile */)
+        if (container === undefined || container.parent === undefined || container.parent.kind !== 308 /* SyntaxKind.SourceFile */)
             continue;
         const exportEquals = getSymbol(container)?.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
         const assignment = exportEquals?.valueDeclaration;
-        if (assignment === undefined || assignment.kind !== 278 /* SyntaxKind.ExportAssignment */)
+        if (assignment === undefined || assignment.kind !== 279 /* SyntaxKind.ExportAssignment */)
             continue;
         let exported = getSymbolAtLocation(c, getExpression(assignment));
         if (exported === undefined)
@@ -709,26 +829,26 @@ function tryGetModuleNameFromAmbientModule(c, moduleSymbol) {
         if ((exported.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
             exported = resolveAlias(c, exported);
         if (exported === getSymbol(d))
-            return getText(getName(container));
+            return container;
     }
-    return '';
+    return undefined;
 }
 function isModuleWithStringLiteralName(node) {
-    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getName(node)?.kind === 10 /* SyntaxKind.StringLiteral */;
+    return node.kind === 269 /* SyntaxKind.ModuleDeclaration */ && getName(node)?.kind === 10 /* SyntaxKind.StringLiteral */;
 }
 function canHaveModuleSpecifier(node) {
     switch (node.kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 209 /* SyntaxKind.BindingElement */:
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 274 /* SyntaxKind.ImportClause */:
-        case 281 /* SyntaxKind.NamespaceExport */:
-        case 275 /* SyntaxKind.NamespaceImport */:
-        case 282 /* SyntaxKind.ExportSpecifier */:
-        case 277 /* SyntaxKind.ImportSpecifier */:
-        case 206 /* SyntaxKind.ImportType */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 275 /* SyntaxKind.ImportClause */:
+        case 282 /* SyntaxKind.NamespaceExport */:
+        case 276 /* SyntaxKind.NamespaceImport */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 207 /* SyntaxKind.ImportType */:
             return true;
     }
     return false;
@@ -737,33 +857,33 @@ function canHaveModuleSpecifier(node) {
 function tryGetModuleSpecifierFromDeclaration(node) {
     let specifier;
     switch (node.kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 209 /* SyntaxKind.BindingElement */: {
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 210 /* SyntaxKind.BindingElement */: {
             let call = getInitializer(node);
-            while (call !== undefined && !isRequireCall(call, true))
+            while (call !== undefined && !isRequireCall(call, true) && !isImportCall(call))
                 call = call.parent;
             specifier = call === undefined ? undefined : getArguments(call).nodes[0];
             break;
         }
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
             specifier = getModuleSpecifier(node);
             break;
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             specifier = getExternalModuleName(node);
             break;
-        case 274 /* SyntaxKind.ImportClause */:
-        case 281 /* SyntaxKind.NamespaceExport */:
+        case 275 /* SyntaxKind.ImportClause */:
+        case 282 /* SyntaxKind.NamespaceExport */:
             specifier = getModuleSpecifier(node.parent);
             break;
-        case 275 /* SyntaxKind.NamespaceImport */:
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 276 /* SyntaxKind.NamespaceImport */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             specifier = getModuleSpecifier(node.parent.parent);
             break;
-        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
             specifier = getModuleSpecifier(node.parent.parent.parent);
             break;
-        case 206 /* SyntaxKind.ImportType */: {
+        case 207 /* SyntaxKind.ImportType */: {
             const argument = node.argument;
             specifier = argument instanceof LiteralTypeNode ? argument.literal : undefined;
             break;