Added kind to transformation context.

Author: dragomirtitian

src/compiler/_namespaces/ts.ts

@@ -61,7 +61,6 @@ export * from "../transformers/declarations/emitBinder";
 export * from "../transformers/declarations/emitResolver";
 export * from "../transformers/declarations/transpileDeclaration";
 export * from "../transformers/declarations/localInferenceResolver";
-export * from "../transformers/declarations/types";
 export * from "../transformers/declarations";
 export * from "../transformer";
 export * from "../emitter";

src/compiler/transformer.ts

@@ -4,11 +4,13 @@ import {
     Bundle,
     chainBundle,
     CompilerOptions,
+    CoreEmitResolver,
     createEmitHelperFactory,
     CustomTransformer,
     CustomTransformerFactory,
     CustomTransformers,
     Debug,
+    Diagnostic,
     DiagnosticWithLocation,
     disposeEmitNodes,
     EmitFlags,
@@ -30,6 +32,7 @@ import {
     getUseDefineForClassFields,
     Identifier,
     isBundle,
+    IsolatedTransformationContext,
     isSourceFile,
     LexicalEnvironmentFlags,
     map,
@@ -40,6 +43,7 @@ import {
     NodeFlags,
     noop,
     notImplemented,
+    NullTransformationContext,
     returnUndefined,
     ScriptTarget,
     setEmitFlags,
@@ -49,6 +53,7 @@ import {
     SyntaxKind,
     tracing,
     TransformationContext,
+    TransformationContextKind,
     TransformationResult,
     transformClassFields,
     transformDeclarations,
@@ -267,6 +272,7 @@ export function transformNodes<T extends Node>(resolver: EmitResolver | undefine
     // The transformation context is provided to each transformer as part of transformer
     // initialization.
     const context: TransformationContext = {
+        kind: TransformationContextKind.FullContext,
         factory,
         getCompilerOptions: () => options,
         getEmitResolver: () => resolver!, // TODO: GH#18217
@@ -662,33 +668,51 @@ export function transformNodes<T extends Node>(resolver: EmitResolver | undefine
         }
     }
 }
-
 /** @internal */
-export const nullTransformationContext: TransformationContext = {
-    factory: factory, // eslint-disable-line object-shorthand
-    getCompilerOptions: () => ({}),
-    getEmitResolver: notImplemented,
-    getEmitHost: notImplemented,
-    getEmitHelperFactory: notImplemented,
-    startLexicalEnvironment: noop,
-    resumeLexicalEnvironment: noop,
-    suspendLexicalEnvironment: noop,
-    endLexicalEnvironment: returnUndefined,
-    setLexicalEnvironmentFlags: noop,
-    getLexicalEnvironmentFlags: () => 0,
-    hoistVariableDeclaration: noop,
-    hoistFunctionDeclaration: noop,
-    addInitializationStatement: noop,
-    startBlockScope: noop,
-    endBlockScope: returnUndefined,
-    addBlockScopedVariable: noop,
-    requestEmitHelper: noop,
-    readEmitHelpers: notImplemented,
-    enableSubstitution: noop,
-    enableEmitNotification: noop,
-    isSubstitutionEnabled: notImplemented,
-    isEmitNotificationEnabled: notImplemented,
-    onSubstituteNode: noEmitSubstitution,
-    onEmitNode: noEmitNotification,
-    addDiagnostic: noop,
-};
+export function createTransformationContext(kind: TransformationContextKind.NullContext): NullTransformationContext;
+/** @internal */
+export function createTransformationContext(
+    kind: TransformationContextKind.IsolatedContext,
+    options: CompilerOptions,
+    diagnostics: Diagnostic[],
+    resolver: CoreEmitResolver,
+): IsolatedTransformationContext;
+export function createTransformationContext(
+    kind: TransformationContextKind.IsolatedContext | TransformationContextKind.NullContext,
+    options: CompilerOptions = {},
+    diagnostics?: Diagnostic[],
+    resolver?: EmitResolver | CoreEmitResolver,
+    host?: EmitHost,
+): NullTransformationContext | IsolatedTransformationContext | TransformationContext {
+    return {
+        kind,
+        factory: factory, // eslint-disable-line object-shorthand
+        getCompilerOptions: () => options,
+        getEmitResolver: !resolver ? notImplemented : () => resolver,
+        getEmitHost: !host ? notImplemented : () => host,
+        getEmitHelperFactory: notImplemented,
+        startLexicalEnvironment: noop,
+        resumeLexicalEnvironment: noop,
+        suspendLexicalEnvironment: noop,
+        endLexicalEnvironment: returnUndefined,
+        setLexicalEnvironmentFlags: noop,
+        getLexicalEnvironmentFlags: () => 0,
+        hoistVariableDeclaration: noop,
+        hoistFunctionDeclaration: noop,
+        addInitializationStatement: noop,
+        startBlockScope: noop,
+        endBlockScope: returnUndefined,
+        addBlockScopedVariable: noop,
+        requestEmitHelper: noop,
+        readEmitHelpers: notImplemented,
+        enableSubstitution: noop,
+        enableEmitNotification: noop,
+        isSubstitutionEnabled: notImplemented,
+        isEmitNotificationEnabled: notImplemented,
+        onSubstituteNode: noEmitSubstitution,
+        onEmitNode: noEmitNotification,
+        addDiagnostic: !diagnostics ? noop : (diag: Diagnostic) => diagnostics.push(diag),
+    };
+}
+/** @internal */
+export const nullTransformationContext: NullTransformationContext = createTransformationContext(TransformationContextKind.NullContext);

src/compiler/transformers/declarations.ts

@@ -220,6 +220,7 @@ import {
     SyntaxKind,
     toFileNameLowerCase,
     TransformationContext,
+    TransformationContextKind,
     transformNodes,
     tryCast,
     tryGetModuleSpecifierFromDeclaration,
@@ -292,7 +293,7 @@ const declarationEmitNodeBuilderFlags = NodeBuilderFlags.MultilineObjectLiterals
  *
  * @internal
  */
-export function transformDeclarations(context: (TransformationContext & { useLocalInferenceTypePrint?: false; }) | IsolatedTransformationContext) {
+export function transformDeclarations(context: TransformationContext | IsolatedTransformationContext) {
     const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
     let getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic = throwDiagnostic;
     let needsDeclare = true;
@@ -339,7 +340,7 @@ export function transformDeclarations(context: (TransformationContext & { useLoc
                     return checkEntityNameVisibility(name, container ?? enclosingDeclaration);
                 },
             });
-            if (context.useLocalInferenceTypePrint) {
+            if (context.kind === TransformationContextKind.IsolatedContext) {
                 const resolver: CoreEmitResolver = context.getEmitResolver();
                 // Ideally nothing should require the symbol tracker in isolated declarations mode.
                 // createLiteralConstValue is the one exception
@@ -370,7 +371,7 @@ export function transformDeclarations(context: (TransformationContext & { useLoc
             }
         }
         else {
-            Debug.assert(!context.useLocalInferenceTypePrint);
+            Debug.assert(context.kind === TransformationContextKind.FullContext);
             const host = context.getEmitHost();
             const resolver = context.getEmitResolver();
             const symbolTracker: SymbolTracker = createSymbolTracker(resolver, host);

src/compiler/transformers/declarations/emitBinder.ts

@@ -62,7 +62,6 @@ import {
     isVarConst,
     isVariableDeclaration,
     MappedTypeNode,
-    MemberKey,
     MethodDeclaration,
     MethodSignature,
     ModifierFlags,
@@ -816,6 +815,11 @@ export function bindSourceFileForDeclarationEmit(file: SourceFile) {
     }
 }
 
+/** @internal */
+export type MemberKey = string & {
+    __memberKey: void;
+};
+
 /**
  * Gets the symbolic name for a member from its type.
  * @internal

src/compiler/transformers/declarations/transpileDeclaration.ts

@@ -7,6 +7,7 @@ import {
     createPrinter,
     createSourceMapGenerator,
     createTextWriter,
+    createTransformationContext,
     Debug,
     Diagnostic,
     EmitHost,
@@ -21,11 +22,11 @@ import {
     getSourceFilePathInNewDir,
     normalizePath,
     normalizeSlashes,
-    nullTransformationContext,
     PrinterOptions,
     SourceFile,
     SourceMapGenerator,
     sys,
+    TransformationContextKind,
     transformDeclarations,
     TranspileDeclarationsOptions,
     TranspileDeclarationsOutput,
@@ -46,19 +47,8 @@ export function transpileDeclaration(sourceFile: SourceFile, transpileOptions: T
     };
     const emitResolver = createEmitDeclarationResolver(sourceFile);
     const diagnostics: Diagnostic[] = [];
-    const transformer = transformDeclarations({
-        useLocalInferenceTypePrint: true,
-        ...nullTransformationContext,
-        getEmitResolver() {
-            return emitResolver;
-        },
-        getCompilerOptions() {
-            return compilerOptions;
-        },
-        addDiagnostic(diag: any) {
-            diagnostics.push(diag);
-        },
-    });
+    const transformationContext = createTransformationContext(TransformationContextKind.IsolatedContext, compilerOptions, diagnostics, emitResolver);
+    const transformer = transformDeclarations(transformationContext);
     const result = transformer(sourceFile);
 
     const printer = createPrinter({

src/compiler/transformers/declarations/types.ts

@@ -9167,7 +9167,14 @@ export const enum LexicalEnvironmentFlags {
     VariablesHoistedInParameters = 1 << 1, // a temp variable was hoisted while visiting a parameter list
 }
 
+export const enum TransformationContextKind {
+    FullContext = 0,
+    IsolatedContext = 1,
+    NullContext = 2,
+}
+
 export interface CoreTransformationContext {
+    /** @internal */ kind: TransformationContextKind;
     readonly factory: NodeFactory;
 
     /** Gets the compiler options supplied to the transformer. */
@@ -9209,6 +9216,7 @@ export interface CoreTransformationContext {
 }
 
 export interface TransformationContext extends CoreTransformationContext {
+    kind: TransformationContextKind.FullContext;
     /** @internal */ getEmitResolver(): EmitResolver;
     /** @internal */ getEmitHost(): EmitHost;
     /** @internal */ getEmitHelperFactory(): EmitHelperFactory;
@@ -9258,6 +9266,19 @@ export interface TransformationContext extends CoreTransformationContext {
     /** @internal */ addDiagnostic(diag: DiagnosticWithLocation): void;
 }
 
+/** @internal */
+export interface IsolatedTransformationContext extends CoreTransformationContext {
+    kind: TransformationContextKind.IsolatedContext;
+    getEmitResolver(): CoreEmitResolver;
+    getCompilerOptions(): CompilerOptions;
+    factory: NodeFactory;
+    addDiagnostic(diag: Diagnostic): void;
+}
+/** @internal */
+export interface NullTransformationContext extends CoreTransformationContext {
+    kind: TransformationContextKind.NullContext;
+}
+
 export interface TransformationResult<T extends Node> {
     /** Gets the transformed source files. */
     transformed: T[];

src/compiler/types.ts

@@ -128,6 +128,7 @@ import {
     NodeArray,
     NodeFactoryFlags,
     nodeIsSynthesized,
+    NullTransformationContext,
     nullTransformationContext,
     ObjectLiteralElementLike,
     ObjectLiteralExpression,
@@ -162,7 +163,6 @@ import {
     textSpanEnd,
     Token,
     tokenToString,
-    TransformationContext,
     TypeLiteralNode,
     TypeNode,
     TypeParameterDeclaration,
@@ -1367,7 +1367,7 @@ function isTrivia(s: string) {
 
 // A transformation context that won't perform parenthesization, as some parenthesization rules
 // are more aggressive than is strictly necessary.
-const textChangesTransformationContext: TransformationContext = {
+const textChangesTransformationContext: NullTransformationContext = {
     ...nullTransformationContext,
     factory: createNodeFactory(
         nullTransformationContext.factory.flags | NodeFactoryFlags.NoParenthesizerRules,