Improve declaration emit type safety.

Signed-off-by: Titian Cernicova-Dragomir <[email protected]>

Author: dragomirtitian

src/compiler/transformers/declarations.ts

@@ -23,6 +23,7 @@ import {
     ConstructorTypeNode,
     ConstructSignatureDeclaration,
     contains,
+    CoreEmitResolver,
     createDiagnosticForNode,
     createDiagnosticForRange,
     createEmptyExports,
@@ -138,7 +139,7 @@ import {
     isMethodSignature,
     isModifier,
     isModuleDeclaration,
-    IsolatedEmitResolver,
+    IsolatedTransformationContext,
     isOmittedExpression,
     isPrivateIdentifier,
     isPropertySignature,
@@ -293,7 +294,7 @@ const declarationEmitNodeBuilderFlags = NodeBuilderFlags.MultilineObjectLiterals
  *
  * @internal
  */
-export function transformDeclarations(context: TransformationContext) {
+export function transformDeclarations(context: (TransformationContext & { isIsolatedDeclarationContext?: undefined }) | IsolatedTransformationContext) {
     const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
     let getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic = throwDiagnostic;
     let needsDeclare = true;
@@ -325,7 +326,7 @@ export function transformDeclarations(context: TransformationContext) {
 
     function createTransformerServices(): {
         isolatedDeclarations: true;
-        resolver: IsolatedEmitResolver;
+        resolver: CoreEmitResolver;
         localInferenceResolver: LocalInferenceResolver;
         host: undefined;
         symbolTracker: undefined;
@@ -338,24 +339,28 @@ export function transformDeclarations(context: TransformationContext) {
         symbolTracker: SymbolTracker;
         ensureNoInitializer: (node: CanHaveLiteralInitializer) => Expression | undefined;
     } {
-        const { isolatedDeclarations, resolver: localInferenceResolver } = createLocalInferenceResolver({
-            ensureParameter,
-            context,
-            visitDeclarationSubtree,
-            setEnclosingDeclarations(node) {
-                const oldNode = enclosingDeclaration;
-                enclosingDeclaration = node;
-                return oldNode;
-            },
-            checkEntityNameVisibility(name, container) {
-                return checkEntityNameVisibility(name, container ?? enclosingDeclaration);
-            },
-        });
+        const isolatedDeclarations = context.getCompilerOptions().isolatedDeclarations;
+        // DTE Context or in isolated declarations mode
+        if (context.isIsolatedDeclarationContext || isolatedDeclarations) {
+            Debug.assert(isolatedDeclarations)
+            const localInferenceResolver = createLocalInferenceResolver({
+                ensureParameter,
+                context,
+                visitDeclarationSubtree,
+                setEnclosingDeclarations(node) {
+                    const oldNode = enclosingDeclaration;
+                    enclosingDeclaration = node;
+                    return oldNode;
+                },
+                checkEntityNameVisibility(name, container) {
+                    return checkEntityNameVisibility(name, container ?? enclosingDeclaration);
+                },
+            });
 
-        if (isolatedDeclarations) {
-            const resolver: IsolatedEmitResolver = context.getEmitResolver();
+            
+            const resolver: CoreEmitResolver = context.getEmitResolver();
             // Ideally nothing should require the symbol tracker in isolated declarations mode.
-            // createLiteralConstValue is teh one exception
+            // createLiteralConstValue is the one exception
             const emptySymbolTracker = {};
             return {
                 isolatedDeclarations,
@@ -376,8 +381,8 @@ export function transformDeclarations(context: TransformationContext) {
             const resolver = context.getEmitResolver();
             const symbolTracker: SymbolTracker = createSymbolTracker(resolver, host);
             return {
-                isolatedDeclarations,
-                localInferenceResolver,
+                isolatedDeclarations: false,
+                localInferenceResolver: undefined,
                 resolver,
                 symbolTracker,
                 host,
@@ -626,6 +631,7 @@ export function transformDeclarations(context: TransformationContext) {
             libs = new Map();
             existingTypeReferencesSources = node.sourceFiles;
             let hasNoDefaultLib = false;
+            Debug.assert(!isolatedDeclarations, "Bundles are not supported in isolated declarations")
             const bundle = factory.createBundle(
                 map(node.sourceFiles, sourceFile => {
                     if (sourceFile.isDeclarationFile) return undefined!; // Omit declaration files from bundle results, too // TODO: GH#18217
@@ -648,7 +654,7 @@ export function transformDeclarations(context: TransformationContext) {
                             sourceFile,
                             [factory.createModuleDeclaration(
                                 [factory.createModifier(SyntaxKind.DeclareKeyword)],
-                                factory.createStringLiteral(getResolvedExternalModuleName(context.getEmitHost(), sourceFile)),
+                                factory.createStringLiteral(getResolvedExternalModuleName(host, sourceFile)),
                                 factory.createModuleBlock(setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements)),
                             )],
                             /*isDeclarationFile*/ true,
@@ -1085,7 +1091,7 @@ export function transformDeclarations(context: TransformationContext) {
             if (isBundledEmit) {
                 // Bundle emit not supported for isolatedDeclarations
                 if (!isolatedDeclarations) {
-                    const newName = getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent);
+                    const newName = getExternalModuleNameFromDeclaration(host, resolver, parent);
                     if (newName) {
                         return factory.createStringLiteral(newName);
                     }

src/compiler/transformers/declarations/emitResolver.ts

@@ -2,6 +2,7 @@ import {
     appendIfUnique,
     bindSourceFileForDeclarationEmit,
     ComputedPropertyName,
+    CoreEmitResolver,
     createEvaluator,
     Debug,
     Declaration,
@@ -50,7 +51,6 @@ import {
     isInJSFile,
     isLateVisibilityPaintedStatement,
     isNumericLiteral,
-    IsolatedEmitResolver,
     isPartOfTypeNode,
     isPrefixUnaryExpression,
     isPropertyAccessExpression,
@@ -87,7 +87,7 @@ import {
 
 
 /** @internal */
-export function createEmitDeclarationResolver(file: SourceFile): IsolatedEmitResolver {
+export function createEmitDeclarationResolver(file: SourceFile): CoreEmitResolver {
     const { getNodeLinks, resolveMemberKey, resolveName, resolveEntityName } = bindSourceFileForDeclarationEmit(file);
 
     function getEnumValueFromName(name: PropertyName | NoSubstitutionTemplateLiteral, location: EnumDeclaration) {

src/compiler/transformers/declarations/localInferenceResolver.ts

@@ -5,6 +5,7 @@ import {
     ClassExpression,
     createDiagnosticForNode,
     createPropertyNameNodeForIdentifierOrLiteral,
+    Debug,
     DiagnosticMessage,
     Diagnostics,
     EntityNameOrEntityNameExpression,
@@ -29,6 +30,7 @@ import {
     isMethodDeclaration,
     isNoSubstitutionTemplateLiteral,
     isNumericLiteral,
+    IsolatedTransformationContext,
     isOmittedExpression,
     isOptionalDeclaration,
     isParameter,
@@ -113,39 +115,34 @@ export function createLocalInferenceResolver({
     visitDeclarationSubtree(input: Node): VisitResult<Node | undefined>;
     checkEntityNameVisibility(name: EntityNameOrEntityNameExpression, container?: Node): void;
     ensureParameter(p: ParameterDeclaration): ParameterDeclaration;
-    context: TransformationContext;
-}): { resolver: LocalInferenceResolver; isolatedDeclarations: true; } | { resolver: undefined; isolatedDeclarations: false; } {
+    context: IsolatedTransformationContext | TransformationContext;
+}): LocalInferenceResolver {
     let currentSourceFile: SourceFile;
     const options = context.getCompilerOptions();
     const resolver = context.getEmitResolver();
-    if (!options.isolatedDeclarations) {
-        return { resolver: undefined, isolatedDeclarations: false };
-    }
+    Debug.assert(options.isolatedDeclarations, "createLocalInferenceResolver");
     const { factory } = context;
     const strictNullChecks = !!options.strict || !!options.strictNullChecks;
 
-    return {
-        resolver: {
-            fromInitializer(node: HasInferredType, type: TypeNode | undefined, sourceFile: SourceFile) {
-                const oldSourceFile = currentSourceFile;
-                currentSourceFile = sourceFile;
-                try {
-                    const localType = localInferenceFromInitializer(node, type);
-                    if (localType !== undefined) {
-                        return localType;
-                    }
-                    if (type) {
-                        return visitNode(type, visitDeclarationSubtree, isTypeNode)!;
-                    }
-                    return makeInvalidType();
+    return  {
+        fromInitializer(node: HasInferredType, type: TypeNode | undefined, sourceFile: SourceFile) {
+            const oldSourceFile = currentSourceFile;
+            currentSourceFile = sourceFile;
+            try {
+                const localType = localInferenceFromInitializer(node, type);
+                if (localType !== undefined) {
+                    return localType;
                 }
-                finally {
-                    currentSourceFile = oldSourceFile;
+                if (type) {
+                    return visitNode(type, visitDeclarationSubtree, isTypeNode)!;
                 }
-            },
-            makeInvalidType,
+                return makeInvalidType();
+            }
+            finally {
+                currentSourceFile = oldSourceFile;
+            }
         },
-        isolatedDeclarations: options.isolatedDeclarations,
+        makeInvalidType,
     };
     function hasParseError(node: Node) {
         return !!(node.flags & NodeFlags.ThisNodeHasError);

src/compiler/transformers/declarations/transpileDeclaration.ts

@@ -11,7 +11,6 @@ import {
     Diagnostic,
     EmitHost,
     ensureTrailingDirectorySeparator,
-    factory,
     getAreDeclarationMapsEnabled,
     getBaseFileName,
     getDeclarationEmitOutputFilePathWorker,
@@ -22,74 +21,44 @@ import {
     getSourceFilePathInNewDir,
     normalizePath,
     normalizeSlashes,
+    nullTransformationContext,
     PrinterOptions,
     SourceFile,
     SourceMapGenerator,
     sys,
-    TransformationContext,
     transformDeclarations,
     TranspileDeclarationsOptions,
     TranspileDeclarationsOutput,
 } from "../../_namespaces/ts";
 
-function createEmitDeclarationHost(options: TranspileDeclarationsOptions): EmitHost {
-    const throws = () => Debug.fail("Function should not be called in isolated declarations emit");
-    return {
-        getCurrentDirectory: () => options.currentDirectory ?? ".",
-        getCanonicalFileName: createGetCanonicalFileName(sys.useCaseSensitiveFileNames),
-        useCaseSensitiveFileNames: () => !!options.useCaseSensitiveFileNames,
-        getCompilerOptions: () => options.compilerOptions,
-        getCommonSourceDirectory: () => ensureTrailingDirectorySeparator(options.commonSourceDirectory ?? "."),
-        get redirectTargetsMap(): never {
-            Debug.fail("redirectTargetsMap should not be used in isolated declarations");
-            return undefined!; // Need return despite fail call GH#52214
-        },
-        directoryExists: throws,
-        fileExists: throws,
-        readFile: throws,
-        realpath: throws,
-        getLibFileFromReference: throws,
-        getSourceFileFromReference: throws,
-        isSourceOfProjectReferenceRedirect: throws,
-
-        getSourceFiles: throws,
-        isEmitBlocked: throws,
-        getPrependNodes: throws,
-        writeFile: throws,
-        getBuildInfo: throws,
-        getSourceFile: throws,
-        getSourceFileByPath: throws,
-        getProjectReferenceRedirect: throws,
-        getFileIncludeReasons: throws,
-        isSourceFileFromExternalLibrary: throws,
-        getResolvedProjectReferenceToRedirect: throws,
-    };
-}
-
 export function transpileDeclaration(sourceFile: SourceFile, transpileOptions: TranspileDeclarationsOptions): TranspileDeclarationsOutput {
     const compilerOptions: CompilerOptions = {
         ...transpileOptions.compilerOptions,
         isolatedDeclarations: true,
         traceResolution: false,
     };
-    const emitHost = createEmitDeclarationHost(transpileOptions);
+    const emitHost = {
+        getCurrentDirectory: () => transpileOptions.currentDirectory ?? ".",
+        getCanonicalFileName: createGetCanonicalFileName(!!compilerOptions.useCaseSensitiveFileNames),
+        useCaseSensitiveFileNames: () => !!compilerOptions.useCaseSensitiveFileNames,
+        getCompilerOptions: () => compilerOptions.compilerOptions,
+        getCommonSourceDirectory: () => ensureTrailingDirectorySeparator(transpileOptions.commonSourceDirectory ?? "."),
+    };
     const emitResolver = createEmitDeclarationResolver(sourceFile);
     const diagnostics: Diagnostic[] = [];
     const transformer = transformDeclarations({
-        getEmitHost() {
-            return emitHost;
-        },
+        isIsolatedDeclarationContext: true,
+        ...nullTransformationContext,
         getEmitResolver() {
             return emitResolver;
         },
         getCompilerOptions() {
-            return emitHost.getCompilerOptions();
+            return compilerOptions;
         },
-        factory,
         addDiagnostic(diag: any) {
             diagnostics.push(diag);
         },
-    } as TransformationContext);
+    });
     const result = transformer(sourceFile);
 
     const printer = createPrinter({

src/compiler/transformers/declarations/types.ts

@@ -1,51 +1,21 @@
 import {
-    AccessorDeclaration,
-    AllAccessorDeclarations,
-    AnyImportSyntax,
-    ComputedPropertyName,
-    Declaration,
-    ElementAccessExpression,
-    EntityNameOrEntityNameExpression,
-    EnumMember,
-    Expression,
-    FunctionDeclaration,
-    ImportDeclaration,
-    LateBoundDeclaration,
-    Node,
-    ParameterDeclaration,
-    PropertyAccessExpression,
-    PropertyDeclaration,
-    PropertySignature,
-    ResolutionMode,
-    SignatureDeclaration,
-    StringLiteralLike,
-    Symbol,
-    SymbolTracker,
-    SymbolVisibilityResult,
-    VariableDeclaration,
+    CompilerOptions,
+    CoreEmitResolver,
+    CoreTransformationContext,
+    Diagnostic,
+    NodeFactory,
 } from "../../_namespaces/ts";
 
+/** @internal */
+export interface IsolatedTransformationContext extends CoreTransformationContext {
+    isIsolatedDeclarationContext: true;
+    getEmitResolver(): CoreEmitResolver;
+    getCompilerOptions(): CompilerOptions;
+    factory: NodeFactory;
+    addDiagnostic(diag: Diagnostic): void;
+}
+
 /** @internal */
 export type MemberKey = string & {
     __memberKey: void;
 };
-
-/** @internal */
-export interface IsolatedEmitResolver {
-    isLiteralComputedName(node: ComputedPropertyName): boolean;
-    isDeclarationVisible(node: Declaration | AnyImportSyntax): boolean;
-    isLateBound(node: Declaration): node is LateBoundDeclaration;
-    isImplementationOfOverload(node: SignatureDeclaration): boolean | undefined;
-    isExpandoFunction(node: VariableDeclaration | FunctionDeclaration): boolean;
-    createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker): Expression;
-    isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
-    isOptionalParameter(node: ParameterDeclaration): boolean;
-    getTypeReferenceDirectivesForEntityName(name: EntityNameOrEntityNameExpression): [specifier: string, mode: ResolutionMode | undefined][] | undefined;
-    isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean;
-    getSymbolOfExternalModuleSpecifier(node: StringLiteralLike): Symbol | undefined;
-    isImportRequiredByAugmentation(decl: ImportDeclaration): boolean;
-    getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): string | number | undefined;
-    getAllAccessorDeclarations(declaration: AccessorDeclaration): AllAccessorDeclarations;
-    tryFindAmbientModule(moduleReferenceExpression: Expression): Symbol | undefined;
-    getPropertiesOfContainerFunction(node: FunctionDeclaration | VariableDeclaration): Symbol[]
-}