microsoft · rbuckton · Mar 18, 2016 · Feb 4, 2016 · Feb 5, 2016 · Feb 5, 2016
diff --git a/src/compiler/printer.ts b/src/compiler/printer.ts
@@ -152,8 +152,7 @@ const _super = (function (geti, seti) {
             let isEmitNotificationEnabled: (node: Node) => boolean;
             let expressionSubstitution: (node: Expression) => Expression;
             let identifierSubstitution: (node: Identifier) => Identifier;
-            let onBeforeEmitNode: (node: Node) => void;
-            let onAfterEmitNode: (node: Node) => void;
+            let onEmitNode: (node: Node, emit: (node: Node) => void) => void;
             let nodeToGeneratedName: string[];
             let generatedNameSet: Map<string>;
             let tempFlags: TempFlags;
@@ -215,8 +214,7 @@ const _super = (function (geti, seti) {
                 isEmitNotificationEnabled = undefined;
                 expressionSubstitution = undefined;
                 identifierSubstitution = undefined;
-                onBeforeEmitNode = undefined;
-                onAfterEmitNode = undefined;
+                onEmitNode = undefined;
                 tempFlags = TempFlags.Auto;
                 currentSourceFile = undefined;
                 currentText = undefined;
@@ -237,8 +235,7 @@ const _super = (function (geti, seti) {
                 isEmitNotificationEnabled = context.isEmitNotificationEnabled;
                 expressionSubstitution = context.expressionSubstitution;
                 identifierSubstitution = context.identifierSubstitution;
-                onBeforeEmitNode = context.onBeforeEmitNode;
-                onAfterEmitNode = context.onAfterEmitNode;
+                onEmitNode = context.onEmitNode;
                 return printSourceFile;
             }
 
@@ -252,46 +249,62 @@ const _super = (function (geti, seti) {
                 return node;
             }
 
+            /**
+             * Emits a node.
+             */
             function emit(node: Node) {
-                emitWithWorker(node, emitWorker);
+                emitNodeWithNotificationOption(node, emitWithoutNotificationOption);
+            }
+
+            /**
+             * Emits a node without calling onEmitNode.
+             * NOTE: Do not call this method directly.
+             */
+            function emitWithoutNotificationOption(node: Node) {
+                emitNodeWithWorker(node, emitWorker);
             }
 
+            /**
+             * Emits an expression node.
+             */
             function emitExpression(node: Expression) {
-                emitWithWorker(node, emitExpressionWorker);
+                emitNodeWithNotificationOption(node, emitExpressionWithoutNotificationOption);
+            }
+
+            /**
+             * Emits an expression without calling onEmitNode.
+             * NOTE: Do not call this method directly.
+             */
+            function emitExpressionWithoutNotificationOption(node: Expression) {
+                emitNodeWithWorker(node, emitExpressionWorker);
             }
 
-            function emitWithWorker(node: Node, emitWorker: (node: Node) => void) {
+            /**
+             * Emits a node with emit notification if available.
+             */
+            function emitNodeWithNotificationOption(node: Node, emit: (node: Node) => void) {
                 if (node) {
-                    const adviseOnEmit = isEmitNotificationEnabled(node);
-                    if (adviseOnEmit && onBeforeEmitNode) {
-                        onBeforeEmitNode(node);
+                    if (isEmitNotificationEnabled(node)) {
+                        onEmitNode(node, emit);
+                    }
+                    else {
+                        emit(node);
                     }
+                }
+            }
 
+            function emitNodeWithWorker(node: Node, emitWorker: (node: Node) => void) {
+                if (node) {
                     const leadingComments = getLeadingComments(node, getNotEmittedParent);
                     const trailingComments = getTrailingComments(node, getNotEmittedParent);
                     emitLeadingComments(node, leadingComments);
                     emitStart(node);
                     emitWorker(node);
                     emitEnd(node);
                     emitTrailingComments(node, trailingComments);
-
-                    if (adviseOnEmit && onAfterEmitNode) {
-                        onAfterEmitNode(node);
-                    }
                 }
             }
 
-            function getNotEmittedParent(node: Node): Node {
-                if (getNodeEmitFlags(node) & NodeEmitFlags.EmitCommentsOfNotEmittedParent) {
-                    const parent = getOriginalNode(node).parent;
-                    if (getNodeEmitFlags(parent) & NodeEmitFlags.IsNotEmittedNode) {
-                        return parent;
-                    }
-                }
-
-                return undefined;
-            }
-
             function emitWorker(node: Node): void {
                 const kind = node.kind;
                 switch (kind) {
@@ -2367,6 +2380,17 @@ const _super = (function (geti, seti) {
                     && rangeEndIsOnSameLineAsRangeStart(block, block);
             }
 
+            function getNotEmittedParent(node: Node): Node {
+                if (getNodeEmitFlags(node) & NodeEmitFlags.EmitCommentsOfNotEmittedParent) {
+                    const parent = getOriginalNode(node).parent;
+                    if (getNodeEmitFlags(parent) & NodeEmitFlags.IsNotEmittedNode) {
+                        return parent;
+                    }
+                }
+
+                return undefined;
+            }
+
             function isUniqueName(name: string): boolean {
                 return !resolver.hasGlobalName(name) &&
                     !hasProperty(currentFileIdentifiers, name) &&

diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
@@ -78,8 +78,7 @@ namespace ts {
             expressionSubstitution: node => node,
             enableExpressionSubstitution,
             isExpressionSubstitutionEnabled,
-            onBeforeEmitNode: node => { },
-            onAfterEmitNode: node => { },
+            onEmitNode: (node, emit) => emit(node),
             enableEmitNotification,
             isEmitNotificationEnabled,
         };

diff --git a/src/compiler/transformers/es6.ts b/src/compiler/transformers/es6.ts
@@ -22,10 +22,8 @@ namespace ts {
         const resolver = context.getEmitResolver();
         const previousIdentifierSubstitution = context.identifierSubstitution;
         const previousExpressionSubstitution = context.expressionSubstitution;
-        const previousOnBeforeEmitNode = context.onBeforeEmitNode;
-        const previousOnAfterEmitNode = context.onAfterEmitNode;
-        context.onBeforeEmitNode = onBeforeEmitNode;
-        context.onAfterEmitNode = onAfterEmitNode;
+        const previousOnEmitNode = context.onEmitNode;
+        context.onEmitNode = onEmitNode;
         context.identifierSubstitution = substituteIdentifier;
         context.expressionSubstitution = substituteExpression;
 
@@ -44,23 +42,9 @@ namespace ts {
         let enabledSubstitutions: ES6SubstitutionFlags;
 
         /**
-         * Keeps track of how deeply nested we are within function-likes when printing
-         * nodes. This is used to determine whether we need to emit `_this` instead of
-         * `this`.
+         * This is used to determine whether we need to emit `_this` instead of `this`.
          */
-        let containingFunctionDepth: number;
-
-        /**
-         * The first 31 bits are used to determine whether a containing function is an
-         * arrow function.
-         */
-        let containingFunctionState: number;
-
-        /**
-         * If the containingFunctionDepth grows beyond 31 nested function-likes, this
-         * array is used as a stack to track deeper levels of nesting.
-         */
-        let containingFunctionStack: number[];
+        let useCapturedThis: boolean;
 
         return transformSourceFile;
 
@@ -1715,28 +1699,18 @@ namespace ts {
          *
          * @param node The node to be printed.
          */
-        function onBeforeEmitNode(node: Node) {
-            previousOnBeforeEmitNode(node);
+        function onEmitNode(node: Node, emit: (node: Node) => void) {
+            const savedUseCapturedThis = useCapturedThis;
 
             if (enabledSubstitutions & ES6SubstitutionFlags.CapturedThis && isFunctionLike(node)) {
                 // If we are tracking a captured `this`, push a bit that indicates whether the
                 // containing function is an arrow function.
-                pushContainingFunction(node.kind === SyntaxKind.ArrowFunction);
+                useCapturedThis = node.kind === SyntaxKind.ArrowFunction;
             }
-        }
 
-        /**
-         * Called by the printer just after a node is printed.
-         *
-         * @param node The node that was printed.
-         */
-        function onAfterEmitNode(node: Node) {
-            previousOnAfterEmitNode(node);
+            previousOnEmitNode(node, emit);
 
-            if (enabledSubstitutions & ES6SubstitutionFlags.CapturedThis && isFunctionLike(node)) {
-                // If we are tracking a captured `this`, pop the last containing function bit.
-                popContainingFunction();
-            }
+            useCapturedThis = savedUseCapturedThis;
         }
 
         /**
@@ -1757,7 +1731,6 @@ namespace ts {
         function enableSubstitutionsForCapturedThis() {
             if ((enabledSubstitutions & ES6SubstitutionFlags.CapturedThis) === 0) {
                 enabledSubstitutions |= ES6SubstitutionFlags.CapturedThis;
-                containingFunctionDepth = 0;
                 context.enableExpressionSubstitution(SyntaxKind.ThisKeyword);
                 context.enableEmitNotification(SyntaxKind.Constructor);
                 context.enableEmitNotification(SyntaxKind.MethodDeclaration);
@@ -1850,68 +1823,13 @@ namespace ts {
          * @param node The ThisKeyword node.
          */
         function substituteThisKeyword(node: PrimaryExpression): PrimaryExpression {
-            if (enabledSubstitutions & ES6SubstitutionFlags.CapturedThis && isContainedInArrowFunction()) {
+            if (enabledSubstitutions & ES6SubstitutionFlags.CapturedThis && useCapturedThis) {
                 return createIdentifier("_this", /*location*/ node);
             }
 
             return node;
         }
 
-        /**
-         * Pushes a value onto a stack that indicates whether we are currently printing a node
-         * within an arrow function. This is used to determine whether we need to capture `this`.
-         *
-         * @param isArrowFunction A value indicating whether the current function container is
-         *                        an arrow function.
-         */
-        function pushContainingFunction(isArrowFunction: boolean) {
-            // Encode whether the containing function is an arrow function in the first 31 bits of
-            // an integer. If the stack grows beyond a depth of 31 functions, use an array.
-            if (containingFunctionDepth > 0 && containingFunctionDepth % 31 === 0) {
-                if (!containingFunctionStack) {
-                    containingFunctionStack = [containingFunctionState];
-                }
-                else {
-                    containingFunctionStack.push(containingFunctionState);
-                }
-
-                containingFunctionState = 0;
-            }
-
-            if (isArrowFunction) {
-                containingFunctionState |= 1 << (containingFunctionDepth % 31);
-            }
-
-            containingFunctionDepth++;
-        }
-
-        /**
-         * Pops a value off of the containing function stack.
-         */
-        function popContainingFunction() {
-            if (containingFunctionDepth > 0) {
-                containingFunctionDepth--;
-                if (containingFunctionDepth === 0) {
-                    containingFunctionState = 0;
-                }
-                else if (containingFunctionDepth % 31 === 0) {
-                    containingFunctionState = containingFunctionStack.pop();
-                }
-                else {
-                    containingFunctionState &= ~(1 << containingFunctionDepth % 31);
-                }
-            }
-        }
-
-        /**
-         * Gets a value indicating whether we are currently printing a node inside of an arrow
-         * function.
-         */
-        function isContainedInArrowFunction() {
-            return containingFunctionDepth > 0
-                && containingFunctionState & (1 << (containingFunctionDepth - 1) % 31);
-        }
-
         function getDeclarationName(node: ClassExpression | ClassDeclaration | FunctionDeclaration) {
             return node.name ? getSynthesizedClone(node.name) : getGeneratedNameForNode(node);
         }