Revert changes to track factory source in favor of #51307

Author: rbuckton

src/compiler/emitter.ts

@@ -854,7 +854,7 @@ export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFi
             return;
         }
         // Transform the source files
-        const transform = transformNodes(resolver, host, /*factoryIn*/ undefined, compilerOptions, [sourceFileOrBundle], scriptTransformers, /*allowDtsFiles*/ false);
+        const transform = transformNodes(resolver, host, factory, compilerOptions, [sourceFileOrBundle], scriptTransformers, /*allowDtsFiles*/ false);
 
         const printerOptions: PrinterOptions = {
             removeComments: compilerOptions.removeComments,

src/compiler/factory/nodeFactory.ts

@@ -501,10 +501,10 @@ export function addNodeFactoryPatcher(fn: (factory: NodeFactory) => void) {
  * Creates a `NodeFactory` that can be used to create and update a syntax tree.
  * @param flags Flags that control factory behavior.
  * @param baseFactory A `BaseNodeFactory` used to create the base `Node` objects.
- * @param source The source of the factory, for debugging purposes. Usually a transformer function, but can be any value.
+ *
  * @internal
  */
-export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNodeFactory, source?: unknown): NodeFactory {
+export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNodeFactory): NodeFactory {
     const update = flags & NodeFactoryFlags.NoOriginalNode ? updateWithoutOriginal : updateWithOriginal;
 
     // Lazily load the parenthesizer, node converters, and some factory methods until they are used.
@@ -530,7 +530,6 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         get converters() { return converters(); },
         baseFactory,
         flags,
-        source,
         createNodeArray,
         createNumericLiteral,
         createBigIntLiteral,

src/compiler/transformer.ts

@@ -5,7 +5,6 @@ import {
     chainBundle,
     CompilerOptions,
     createEmitHelperFactory,
-    createNodeFactory,
     CustomTransformer,
     CustomTransformerFactory,
     CustomTransformers,
@@ -73,7 +72,7 @@ import {
     transformNodeModule,
     transformSystemModule,
     transformTypeScript,
-    VariableDeclaration,
+    VariableDeclaration
 } from "./_namespaces/ts";
 import * as performance from "./_namespaces/ts.performance";
 
@@ -244,7 +243,7 @@ export function noEmitNotification(hint: EmitHint, node: Node, callback: (hint:
  *
  * @internal
  */
-export function transformNodes<T extends Node>(resolver: EmitResolver | undefined, host: EmitHost | undefined, factoryIn: NodeFactory | undefined, options: CompilerOptions, nodes: readonly T[], transformers: readonly TransformerFactory<T>[], allowDtsFiles: boolean): TransformationResult<T> {
+export function transformNodes<T extends Node>(resolver: EmitResolver | undefined, host: EmitHost | undefined, factory: NodeFactory, options: CompilerOptions, nodes: readonly T[], transformers: readonly TransformerFactory<T>[], allowDtsFiles: boolean): TransformationResult<T> {
     const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
     let lexicalEnvironmentVariableDeclarations: VariableDeclaration[];
     let lexicalEnvironmentFunctionDeclarations: FunctionDeclaration[];
@@ -268,7 +267,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 = {
-        factory: factoryIn ?? factory,
+        factory,
         getCompilerOptions: () => options,
         getEmitResolver: () => resolver!, // TODO: GH#18217
         getEmitHost: () => host!, // TODO: GH#18217
@@ -316,7 +315,7 @@ export function transformNodes<T extends Node>(resolver: EmitResolver | undefine
     performance.mark("beforeTransform");
 
     // Chain together and initialize each transformer.
-    const transformersWithContext = transformers.map(t => t(factoryIn ? context : createPerTransformerContext(t)));
+    const transformersWithContext = transformers.map(t => t(context));
     const transformation = (node: T): T => {
         for (const transform of transformersWithContext) {
             node = transform(node);
@@ -354,14 +353,6 @@ export function transformNodes<T extends Node>(resolver: EmitResolver | undefine
         return node && (!isSourceFile(node) || !node.isDeclarationFile) ? transformation(node) : node;
     }
 
-    function createPerTransformerContext(t: TransformerFactory<T>) {
-        const perTransformerContext: TransformationContext = Object.create(context, {
-            factory: { value: createNodeFactory(context.factory.flags, context.factory.baseFactory, /*source*/ t) },
-            getEmitHelperFactory: { value: memoize(() => createEmitHelperFactory(perTransformerContext)) },
-        });
-        return perTransformerContext;
-    }
-
     /**
      * Enables expression substitutions in the pretty printer for the provided SyntaxKind.
      */

src/compiler/types.ts

@@ -8273,12 +8273,6 @@ export interface NodeFactory {
     /** @internal */ readonly baseFactory: BaseNodeFactory;
     /** @internal */ readonly flags: NodeFactoryFlags;
 
-    /**
-     * The source of the factory, for debugging purposes. Usually a transformer function, but can be any value.
-     * @internal
-     */
-    source: unknown;
-
     createNodeArray<T extends Node>(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray<T>;
 
     //