Expose transformations as public API

src/compiler/comments.ts

@@ -41,18 +41,14 @@ namespace ts {
             }
 
             if (node) {
-                const { pos, end } = getCommentRange(node);
-                const emitFlags = getEmitFlags(node);
+                hasWrittenComment = false;
+
+                const emitNode = node.emitNode;
+                const emitFlags = emitNode && emitNode.flags;
+                const { pos, end } = emitNode && emitNode.commentRange || node;
                 if ((pos < 0 && end < 0) || (pos === end)) {
                     // Both pos and end are synthesized, so just emit the node without comments.
-                    if (emitFlags & EmitFlags.NoNestedComments) {
-                        disabled = true;
-                        emitCallback(hint, node);
-                        disabled = false;
-                    }
-                    else {
-                        emitCallback(hint, node);
-                    }
+                    emitNodeWithSynthesizedComments(hint, node, emitNode, emitFlags, emitCallback);
                 }
                 else {
                     if (extendedDiagnostics) {
@@ -92,17 +88,10 @@ namespace ts {
                         performance.measure("commentTime", "preEmitNodeWithComment");
                     }
 
-                    if (emitFlags & EmitFlags.NoNestedComments) {
-                        disabled = true;
-                        emitCallback(hint, node);
-                        disabled = false;
-                    }
-                    else {
-                        emitCallback(hint, node);
-                    }
+                    emitNodeWithSynthesizedComments(hint, node, emitNode, emitFlags, emitCallback);
 
                     if (extendedDiagnostics) {
-                        performance.mark("beginEmitNodeWithComment");
+                        performance.mark("postEmitNodeWithComment");
                     }
 
                     // Restore previous container state.
@@ -117,12 +106,89 @@ namespace ts {
                     }
 
                     if (extendedDiagnostics) {
-                        performance.measure("commentTime", "beginEmitNodeWithComment");
+                        performance.measure("commentTime", "postEmitNodeWithComment");
                     }
                 }
             }
         }
 
+        function emitNodeWithSynthesizedComments(hint: EmitHint, node: Node, emitNode: EmitNode, emitFlags: EmitFlags, emitCallback: (hint: EmitHint, node: Node) => void) {
+            const leadingComments = emitNode && emitNode.leadingComments;
+            if (some(leadingComments)) {
+                if (extendedDiagnostics) {
+                    performance.mark("preEmitNodeWithSynthesizedComments");
+                }
+
+                forEach(leadingComments, emitLeadingSynthesizedComment);
+
+                if (extendedDiagnostics) {
+                    performance.measure("commentTime", "preEmitNodeWithSynthesizedComments");
+                }
+            }
+
+            emitNodeWithNestedComments(hint, node, emitFlags, emitCallback);
+
+            const trailingComments = emitNode && emitNode.trailingComments;
+            if (some(trailingComments)) {
+                if (extendedDiagnostics) {
+                    performance.mark("postEmitNodeWithSynthesizedComments");
+                }
+
+                debugger;
+                forEach(trailingComments, emitTrailingSynthesizedComment);
+
+                if (extendedDiagnostics) {
+                    performance.measure("commentTime", "postEmitNodeWithSynthesizedComments");
+                }
+            }
+        }
+
+        function emitLeadingSynthesizedComment(comment: SynthesizedComment) {
+            if (comment.kind === SyntaxKind.SingleLineCommentTrivia) {
+                writer.writeLine();
+            }
+            writeSynthesizedComment(comment);
+            if (comment.hasTrailingNewLine || comment.kind === SyntaxKind.SingleLineCommentTrivia) {
+                writer.writeLine();
+            }
+            else {
+                writer.write(" ");
+            }
+        }
+
+        function emitTrailingSynthesizedComment(comment: SynthesizedComment) {
+            if (!writer.isAtStartOfLine()) {
+                writer.write(" ");
+            }
+            writeSynthesizedComment(comment);
+            if (comment.hasTrailingNewLine) {
+                writer.writeLine();
+            }
+        }
+
+        function writeSynthesizedComment(comment: SynthesizedComment) {
+            const text = formatSynthesizedComment(comment);
+            const lineMap = comment.kind === SyntaxKind.MultiLineCommentTrivia ? computeLineStarts(text) : undefined;
+            writeCommentRange(text, lineMap, writer, 0, text.length, newLine);
+        }
+
+        function formatSynthesizedComment(comment: SynthesizedComment) {
+            return comment.kind === SyntaxKind.MultiLineCommentTrivia
+                ? `/*${comment.text}*/`
+                : `//${comment.text}`;
+        }
+
+        function emitNodeWithNestedComments(hint: EmitHint, node: Node, emitFlags: EmitFlags, emitCallback: (hint: EmitHint, node: Node) => void) {
+            if (emitFlags & EmitFlags.NoNestedComments) {
+                disabled = true;
+                emitCallback(hint, node);
+                disabled = false;
+            }
+            else {
+                emitCallback(hint, node);
+            }
+        }
+
         function emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void) {
             if (extendedDiagnostics) {
                 performance.mark("preEmitBodyWithDetachedComments");

src/compiler/emitter.ts

@@ -10,14 +10,13 @@ namespace ts {
 
     /*@internal*/
     // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature
-    export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile, emitOnlyDtsFiles?: boolean): EmitResult {
+    export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile, emitOnlyDtsFiles?: boolean, transformers?: Transformer[]): EmitResult {
         const compilerOptions = host.getCompilerOptions();
         const moduleKind = getEmitModuleKind(compilerOptions);
         const sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
         const emittedFilesList: string[] = compilerOptions.listEmittedFiles ? [] : undefined;
         const emitterDiagnostics = createDiagnosticCollection();
         const newLine = host.getNewLine();
-        const transformers = emitOnlyDtsFiles ? [] : getTransformers(compilerOptions);
         const writer = createTextWriter(newLine);
         const sourceMap = createSourceMapWriter(host, writer);
 
@@ -56,9 +55,7 @@ namespace ts {
         performance.measure("printTime", "beforePrint");
 
         // Clean up emit nodes on parse tree
-        for (const sourceFile of sourceFiles) {
-            disposeEmitNodes(sourceFile);
-        }
+        transform.dispose();
 
         return {
             emitSkipped,
@@ -756,9 +753,6 @@ namespace ts {
         // SyntaxKind.NumericLiteral
         function emitNumericLiteral(node: NumericLiteral) {
             emitLiteral(node);
-            if (node.trailingComment) {
-                write(` /*${node.trailingComment}*/`);
-            }
         }
 
         // SyntaxKind.StringLiteral

src/compiler/factory.ts

@@ -1906,6 +1906,34 @@ namespace ts {
         return node;
     }
 
+    export function getSyntheticLeadingComments(node: Node): SynthesizedComment[] | undefined {
+        const emitNode = node.emitNode;
+        return emitNode && emitNode.leadingComments;
+    }
+
+    export function setSyntheticLeadingComments<T extends Node>(node: T, comments: SynthesizedComment[]) {
+        getOrCreateEmitNode(node).leadingComments = comments;
+        return node;
+    }
+
+    export function addSyntheticLeadingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean) {
+        return setSyntheticLeadingComments(node, append(getSyntheticLeadingComments(node), <SynthesizedComment>{ kind, pos: -1, end: -1, hasTrailingNewLine, text }));
+    }
+
+    export function getSyntheticTrailingComments(node: Node): SynthesizedComment[] | undefined {
+        const emitNode = node.emitNode;
+        return emitNode && emitNode.trailingComments;
+    }
+
+    export function setSyntheticTrailingComments<T extends Node>(node: T, comments: SynthesizedComment[]) {
+        getOrCreateEmitNode(node).trailingComments = comments;
+        return node;
+    }
+
+    export function addSyntheticTrailingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean) {
+        return setSyntheticTrailingComments(node, append(getSyntheticTrailingComments(node), <SynthesizedComment>{ kind, pos: -1, end: -1, hasTrailingNewLine, text }));
+    }
+
     /**
      * Gets the constant value to emit for an expression.
      */
@@ -2018,6 +2046,8 @@ namespace ts {
     function mergeEmitNode(sourceEmitNode: EmitNode, destEmitNode: EmitNode) {
         const {
             flags,
+            leadingComments,
+            trailingComments,
             commentRange,
             sourceMapRange,
             tokenSourceMapRanges,
@@ -2025,6 +2055,8 @@ namespace ts {
             helpers
         } = sourceEmitNode;
         if (!destEmitNode) destEmitNode = {};
+        if (leadingComments) destEmitNode.leadingComments = addRange(leadingComments.slice(), destEmitNode.leadingComments);
+        if (trailingComments) destEmitNode.trailingComments = addRange(trailingComments.slice(), destEmitNode.trailingComments);
         if (flags) destEmitNode.flags = flags;
         if (commentRange) destEmitNode.commentRange = commentRange;
         if (sourceMapRange) destEmitNode.sourceMapRange = sourceMapRange;

src/compiler/parser.ts

@@ -5816,7 +5816,11 @@ namespace ts {
                     }
                 }
 
-                const range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() };
+                const range = {
+                    kind: <SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia>triviaScanner.getToken(),
+                    pos: triviaScanner.getTokenPos(),
+                    end: triviaScanner.getTextPos(),
+                };
 
                 const comment = sourceText.substring(range.pos, range.end);
                 const referencePathMatchResult = getFileReferenceFromReferencePath(comment, range);

src/compiler/program.ts

@@ -754,15 +754,15 @@ namespace ts {
             return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = createTypeChecker(program, /*produceDiagnostics:*/ false));
         }
 
-        function emit(sourceFile?: SourceFile, writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult {
-            return runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles));
+        function emit(sourceFile?: SourceFile, writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, transformers?: CustomTransformers): EmitResult {
+            return runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers));
         }
 
         function isEmitBlocked(emitFileName: string): boolean {
             return hasEmitBlockingDiagnostics.contains(toPath(emitFileName, currentDirectory, getCanonicalFileName));
         }
 
-        function emitWorker(program: Program, sourceFile: SourceFile, writeFileCallback: WriteFileCallback, cancellationToken: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult {
+        function emitWorker(program: Program, sourceFile: SourceFile, writeFileCallback: WriteFileCallback, cancellationToken: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult {
             let declarationDiagnostics: Diagnostic[] = [];
 
             if (options.noEmit) {
@@ -804,11 +804,13 @@ namespace ts {
 
             performance.mark("beforeEmit");
 
+            const transformers = emitOnlyDtsFiles ? [] : getTransformers(options, customTransformers);
             const emitResult = emitFiles(
                 emitResolver,
                 getEmitHost(writeFileCallback),
                 sourceFile,
-                emitOnlyDtsFiles);
+                emitOnlyDtsFiles,
+                transformers);
 
             performance.mark("afterEmit");
             performance.measure("Emit", "beforeEmit", "afterEmit");

src/compiler/scanner.ts

@@ -608,10 +608,10 @@ namespace ts {
      * @returns If "reduce" is true, the accumulated value. If "reduce" is false, the first truthy
      *      return value of the callback.
      */
-    function iterateCommentRanges<T, U>(reduce: boolean, text: string, pos: number, trailing: boolean, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial?: U): U {
+    function iterateCommentRanges<T, U>(reduce: boolean, text: string, pos: number, trailing: boolean, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial?: U): U {
         let pendingPos: number;
         let pendingEnd: number;
-        let pendingKind: SyntaxKind;
+        let pendingKind: CommentKind;
         let pendingHasTrailingNewLine: boolean;
         let hasPendingCommentRange = false;
         let collecting = trailing || pos === 0;
@@ -707,28 +707,28 @@ namespace ts {
         return accumulator;
     }
 
-    export function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
+    export function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
         return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ false, cb, state);
     }
 
-    export function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
+    export function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
         return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ true, cb, state);
     }
 
-    export function reduceEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U) {
+    export function reduceEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U) {
         return iterateCommentRanges(/*reduce*/ true, text, pos, /*trailing*/ false, cb, state, initial);
     }
 
-    export function reduceEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U) {
+    export function reduceEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U) {
         return iterateCommentRanges(/*reduce*/ true, text, pos, /*trailing*/ true, cb, state, initial);
     }
 
-    function appendCommentRange(pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, _state: any, comments: CommentRange[]) {
+    function appendCommentRange(pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, _state: any, comments: CommentRange[]) {
         if (!comments) {
             comments = [];
         }
 
-        comments.push({ pos, end, hasTrailingNewLine, kind });
+        comments.push({ kind, pos, end, hasTrailingNewLine });
         return comments;
     }
 

src/compiler/transformer.ts

@@ -29,12 +29,14 @@ namespace ts {
         EmitNotifications = 1 << 1,
     }
 
-    export function getTransformers(compilerOptions: CompilerOptions) {
+    export function getTransformers(compilerOptions: CompilerOptions, customTransformers?: CustomTransformers) {
         const jsx = compilerOptions.jsx;
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const moduleKind = getEmitModuleKind(compilerOptions);
         const transformers: Transformer[] = [];
 
+        addRange(transformers, customTransformers && customTransformers.before);
+
         transformers.push(transformTypeScript);
 
         if (jsx === JsxEmit.React) {
@@ -66,6 +68,8 @@ namespace ts {
             transformers.push(transformES5);
         }
 
+        addRange(transformers, customTransformers && customTransformers.after);
+
         return transformers;
     }
 
@@ -79,16 +83,13 @@ namespace ts {
      */
     export function transformFiles(resolver: EmitResolver, host: EmitHost, sourceFiles: SourceFile[], transformers: Transformer[]): TransformationResult {
         const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
-
         let lexicalEnvironmentDisabled = false;
-
         let lexicalEnvironmentVariableDeclarations: VariableDeclaration[];
         let lexicalEnvironmentFunctionDeclarations: FunctionDeclaration[];
         let lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
         let lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
         let lexicalEnvironmentStackOffset = 0;
         let lexicalEnvironmentSuspended = false;
-
         let emitHelpers: EmitHelper[];
 
         // The transformation context is provided to each transformer as part of transformer
@@ -113,6 +114,9 @@ namespace ts {
             isEmitNotificationEnabled
         };
 
+        // Ensure the parse tree is clean before applying transformations
+        dispose();
+
         performance.mark("beforeTransform");
 
         // Chain together and initialize each transformer.
@@ -130,7 +134,8 @@ namespace ts {
         return {
             transformed,
             emitNodeWithSubstitution,
-            emitNodeWithNotification
+            emitNodeWithNotification,
+            dispose
         };
 
         /**
@@ -323,5 +328,12 @@ namespace ts {
             emitHelpers = undefined;
             return helpers;
         }
+
+        function dispose() {
+            // Clean up emit nodes on parse tree
+            for (const sourceFile of sourceFiles) {
+                disposeEmitNodes(sourceFile);
+            }
+        }
     }
 }

src/compiler/transformers/generators.ts

@@ -2419,7 +2419,7 @@ namespace ts {
          */
         function createInstruction(instruction: Instruction): NumericLiteral {
             const literal = createLiteral(instruction);
-            literal.trailingComment = getInstructionName(instruction);
+            addSyntheticTrailingComment(literal, SyntaxKind.MultiLineCommentTrivia, getInstructionName(instruction));
             return literal;
         }
 

src/compiler/transformers/ts.ts

@@ -3312,17 +3312,20 @@ namespace ts {
         function substituteConstantValue(node: PropertyAccessExpression | ElementAccessExpression): LeftHandSideExpression {
             const constantValue = tryGetConstEnumValue(node);
             if (constantValue !== undefined) {
+                // track the constant value on the node for the printer in needsDotDotForPropertyAccess
+                setConstantValue(node, constantValue);
+
                 const substitute = createLiteral(constantValue);
-                setSourceMapRange(substitute, node);
-                setCommentRange(substitute, node);
                 if (!compilerOptions.removeComments) {
                     const propertyName = isPropertyAccessExpression(node)
                         ? declarationNameToString(node.name)
                         : getTextOfNode(node.argumentExpression);
-                    substitute.trailingComment = ` ${propertyName} `;
+
+                    addSyntheticTrailingComment(substitute, SyntaxKind.MultiLineCommentTrivia, ` ${propertyName} `);
+                    // wrap the substituted node so that it emits its own comments.
+                    return createPartiallyEmittedExpression(substitute);
                 }
 
-                setConstantValue(node, constantValue);
                 return substitute;
             }
 

src/compiler/types.ts

@@ -1313,7 +1313,6 @@
 
     export interface NumericLiteral extends LiteralExpression {
         kind: SyntaxKind.NumericLiteral;
-        trailingComment?: string;
     }
 
     export interface TemplateHead extends LiteralLikeNode {
@@ -1893,9 +1892,17 @@
         fileName: string;
     }
 
+    export type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia;
+
     export interface CommentRange extends TextRange {
         hasTrailingNewLine?: boolean;
-        kind: SyntaxKind;
+        kind: CommentKind;
+    }
+
+    export interface SynthesizedComment extends CommentRange {
+        text: string;
+        pos: -1;
+        end: -1;
     }
 
     // represents a top level: { type } expression in a JSDoc comment.
@@ -2265,7 +2272,7 @@
          * used for writing the JavaScript and declaration files.  Otherwise, the writeFile parameter
          * will be invoked when writing the JavaScript and declaration files.
          */
-        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult;
+        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult;
 
         getOptionsDiagnostics(cancellationToken?: CancellationToken): Diagnostic[];
         getGlobalDiagnostics(cancellationToken?: CancellationToken): Diagnostic[];
@@ -2299,6 +2306,13 @@
         /* @internal */ structureIsReused?: boolean;
     }
 
+    export interface CustomTransformers {
+        /** Custom transformers to evaluate before built-in transformations. */
+        before?: Transformer[];
+        /** Custom transformers to evaluate after built-in transformations. */
+        after?: Transformer[];
+    }
+
     export interface SourceMapSpan {
         /** Line number in the .js file. */
         emittedLine: number;
@@ -3724,9 +3738,11 @@
     export interface EmitNode {
         annotatedNodes?: Node[];                // Tracks Parse-tree nodes with EmitNodes for eventual cleanup.
         flags?: EmitFlags;                      // Flags that customize emit
+        leadingComments?: SynthesizedComment[]; // Synthesized leading comments
+        trailingComments?: SynthesizedComment[]; // Synthesized trailing comments
         commentRange?: TextRange;               // The text range to use when emitting leading or trailing comments
         sourceMapRange?: TextRange;             // The text range to use when emitting leading or trailing source mappings
-        tokenSourceMapRanges?: TextRange[];  // The text range to use when emitting source mappings for tokens
+        tokenSourceMapRanges?: TextRange[];     // The text range to use when emitting source mappings for tokens
         constantValue?: number;                 // The constant value of an expression
         externalHelpersModuleName?: Identifier; // The local name for an imported helpers module
         helpers?: EmitHelper[];                 // Emit helpers for the node
@@ -3762,7 +3778,7 @@
 
     export interface EmitHelper {
         readonly name: string;      // A unique name for this helper.
-        readonly scoped: boolean;   // Indicates whether ther helper MUST be emitted in the current scope.
+        readonly scoped: boolean;   // Indicates whether the helper MUST be emitted in the current scope.
         readonly text: string;      // ES3-compatible raw script text.
         readonly priority?: number; // Helpers with a higher priority are emitted earlier than other helpers on the node.
     }
@@ -3809,11 +3825,10 @@
         writeFile: WriteFileCallback;
     }
 
-    /* @internal */
     export interface TransformationContext {
-        getCompilerOptions(): CompilerOptions;
-        getEmitResolver(): EmitResolver;
-        getEmitHost(): EmitHost;
+        /*@internal*/ getCompilerOptions(): CompilerOptions;
+        /*@internal*/ getEmitResolver(): EmitResolver;
+        /*@internal*/ getEmitHost(): EmitHost;
 
         /** Starts a new lexical environment. */
         startLexicalEnvironment(): void;
@@ -3882,7 +3897,6 @@
         onEmitNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
     }
 
-    /* @internal */
     export interface TransformationResult {
         /**
          * Gets the transformed source files.
@@ -3906,9 +3920,13 @@
          * @param emitCallback A callback used to emit the node.
          */
         emitNodeWithNotification(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
+
+        /**
+         * Clean up EmitNode entries on any parse-tree nodes.
+         */
+        dispose(): void;
     }
 
-    /* @internal */
     export type Transformer = (context: TransformationContext) => (node: SourceFile) => SourceFile;
 
     export interface Printer {