diff --git a/src/services/formatting/formatter.ts b/src/services/formatting/formatter.ts
index e4a1229abef..a98d969c059 100644
--- a/src/services/formatting/formatter.ts
+++ b/src/services/formatting/formatter.ts
@@ -52,7 +52,7 @@ module TypeScript.Services.Formatting {
             rulesProvider: RulesProvider,
             formattingRequestKind: FormattingRequestKind): TextEditInfo[] {
             var walker = new Formatter(textSpan, sourceUnit, indentFirstToken, options, snapshot, rulesProvider, formattingRequestKind);
-            visitNodeOrToken(walker, sourceUnit);
+            walker.walk(sourceUnit);
             return walker.edits();
         }
 
diff --git a/src/services/formatting/indentationTrackingWalker.ts b/src/services/formatting/indentationTrackingWalker.ts
index b07b477623e..9e9c9e43a64 100644
--- a/src/services/formatting/indentationTrackingWalker.ts
+++ b/src/services/formatting/indentationTrackingWalker.ts
@@ -16,7 +16,7 @@
 ///<reference path='formatting.ts' />
 
 module TypeScript.Services.Formatting {
-    export class IndentationTrackingWalker extends SyntaxWalker {
+    export class IndentationTrackingWalker /*extends SyntaxWalker*/ {
         private _position: number = 0;
         private _parent: IndentationNodeContext = null;
         private _textSpan: TextSpan;
@@ -26,7 +26,7 @@ module TypeScript.Services.Formatting {
         private _text: ISimpleText;
 
         constructor(textSpan: TextSpan, sourceUnit: SourceUnitSyntax, snapshot: ITextSnapshot, indentFirstToken: boolean, public options: FormattingOptions) {
-            super();
+            // super();
 
             // Create a pool object to manage context nodes while walking the tree
             this._indentationNodeContextPool = new IndentationNodeContextPool();
@@ -100,7 +100,23 @@ module TypeScript.Services.Formatting {
             this._position += token.fullWidth();
         }
 
-        public visitNode(node: ISyntaxNode): void {
+        public walk(element: ISyntaxElement) {
+            if (element && !isShared(element)) {
+                if (isToken(element)) {
+                    this.visitToken(<ISyntaxToken>element);
+                }
+                else if (element.kind() === SyntaxKind.List || element.kind() === SyntaxKind.SeparatedList) {
+                    for (var i = 0, n = childCount(element); i < n; i++) {
+                        this.walk(childAt(element, i));
+                    }
+                }
+                else {
+                    this.visitNode(<ISyntaxNode>element);
+                }
+            }
+        }
+
+        private visitNode(node: ISyntaxNode): void {
             var nodeSpan = new TextSpan(this._position, fullWidth(node));
 
             if (nodeSpan.intersectsWithTextSpan(this._textSpan)) {
@@ -112,7 +128,9 @@ module TypeScript.Services.Formatting {
                 this._parent = this._indentationNodeContextPool.getNode(currentParent, node, this._position, indentation.indentationAmount, indentation.indentationAmountDelta);
 
                 // Visit node
-                visitNodeOrToken(this, node);
+                for (var i = 0, n = childCount(node); i < n; i++) {
+                    this.walk(childAt(node, i));
+                }
 
                 // Reset state
                 this._indentationNodeContextPool.releaseNode(this._parent);
diff --git a/src/services/syntax/depthLimitedWalker.ts b/src/services/syntax/depthLimitedWalker.ts
index 79df1ebd836..c697ed42495 100644
--- a/src/services/syntax/depthLimitedWalker.ts
+++ b/src/services/syntax/depthLimitedWalker.ts
@@ -1,21 +1,21 @@
 ///<reference path='references.ts' />
 
 module TypeScript {
-    export class DepthLimitedWalker extends SyntaxWalker {
-        private _depth: number = 0;
-        private _maximumDepth: number = 0;
+    //export class DepthLimitedWalker extends SyntaxWalker {
+    //    private _depth: number = 0;
+    //    private _maximumDepth: number = 0;
 
-        constructor(maximumDepth: number) {
-            super();
-            this._maximumDepth = maximumDepth;
-        }
+    //    constructor(maximumDepth: number) {
+    //        super();
+    //        this._maximumDepth = maximumDepth;
+    //    }
 
-        public visitNode(node: ISyntaxNode): void {
-            if (this._depth < this._maximumDepth) {
-                this._depth++;
-                super.visitNode(node);
-                this._depth--;
-            }
-        }
-    }
+    //    public visitNode(node: ISyntaxNode): void {
+    //        if (this._depth < this._maximumDepth) {
+    //            this._depth++;
+    //            super.visitNode(node);
+    //            this._depth--;
+    //        }
+    //    }
+    //}
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxGenerator.ts b/src/services/syntax/syntaxGenerator.ts
index b6b3e51ecff..5c28954a1c2 100644
--- a/src/services/syntax/syntaxGenerator.ts
+++ b/src/services/syntax/syntaxGenerator.ts
@@ -2311,19 +2311,19 @@ function generateWalker(): string {
 "    export class SyntaxWalker implements ISyntaxVisitor {\r\n" +
 "        public visitToken(token: ISyntaxToken): void {\r\n" +
 "        }\r\n" +
-"\r\n" +
-"        public visitNode(node: ISyntaxNode): void {\r\n" +
-"            visitNodeOrToken(this, node);\r\n" +
-"        }\r\n" +
-"\r\n" +
-"        public visitNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {\r\n" +
-"            if (isToken(nodeOrToken)) { \r\n" +
-"                this.visitToken(<ISyntaxToken>nodeOrToken);\r\n" +
-"            }\r\n" +
-"            else {\r\n" +
-"                this.visitNode(<ISyntaxNode>nodeOrToken);\r\n" +
-"            }\r\n" +
-"        }\r\n" +
+//"\r\n" +
+//"        public visitNode(node: ISyntaxNode): void {\r\n" +
+//"            visitNodeOrToken(this, node);\r\n" +
+//"        }\r\n" +
+//"\r\n" +
+//"        public visitNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {\r\n" +
+//"            if (isToken(nodeOrToken)) { \r\n" +
+//"                this.visitToken(<ISyntaxToken>nodeOrToken);\r\n" +
+//"            }\r\n" +
+//"            else {\r\n" +
+//"                this.visitNode(<ISyntaxNode>nodeOrToken);\r\n" +
+//"            }\r\n" +
+//"        }\r\n" +
 "\r\n" +
 "        private visitOptionalToken(token: ISyntaxToken): void {\r\n" +
 "            if (token === undefined) {\r\n" +
@@ -2332,33 +2332,33 @@ function generateWalker(): string {
 "\r\n" +
 "            this.visitToken(token);\r\n" +
 "        }\r\n" +
-"\r\n" +
-"        public visitOptionalNode(node: ISyntaxNode): void {\r\n" +
-"            if (node === undefined) {\r\n" +
-"                return;\r\n" +
-"            }\r\n" +
-"\r\n" +
-"            this.visitNode(node);\r\n" +
-"        }\r\n" +
-"\r\n" +
-"        public visitOptionalNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {\r\n" +
-"            if (nodeOrToken === undefined) {\r\n" +
-"                return;\r\n" +
-"            }\r\n" +
-"\r\n" +
-"            this.visitNodeOrToken(nodeOrToken);\r\n" +
-"        }\r\n" +
+//"\r\n" +
+//"        public visitOptionalNode(node: ISyntaxNode): void {\r\n" +
+//"            if (node === undefined) {\r\n" +
+//"                return;\r\n" +
+//"            }\r\n" +
+//"\r\n" +
+//"            this.visitNode(node);\r\n" +
+//"        }\r\n" +
+//"\r\n" +
+//"        public visitOptionalNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {\r\n" +
+//"            if (nodeOrToken === undefined) {\r\n" +
+//"                return;\r\n" +
+//"            }\r\n" +
+//"\r\n" +
+//"            this.visitNodeOrToken(nodeOrToken);\r\n" +
+//"        }\r\n" +
 "\r\n" +
 "        public visitList(list: ISyntaxNodeOrToken[]): void {\r\n" +
 "            for (var i = 0, n = list.length; i < n; i++) {\r\n" +
-"               this.visitNodeOrToken(list[i]);\r\n" +
+"               visitNodeOrToken(this, list[i]);\r\n" +
 "            }\r\n" +
 "        }\r\n" +
 "\r\n" +
 "        public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {\r\n" +
 "            for (var i = 0, n = childCount(list); i < n; i++) {\r\n" +
 "                var item = childAt(list, i);\r\n" +
-"                this.visitNodeOrToken(item);\r\n" + 
+"                visitNodeOrToken(this, item);\r\n" + 
 "            }\r\n" +
 "        }\r\n";
 
@@ -2386,20 +2386,20 @@ function generateWalker(): string {
                 result += "            this.visitSeparatedList(node." + child.name + ");\r\n";
             }
             else if (isNodeOrToken(child)) {
-                if (child.isOptional) {
-                    result += "            this.visitOptionalNodeOrToken(node." + child.name + ");\r\n";
-                }
-                else {
-                    result += "            this.visitNodeOrToken(node." + child.name + ");\r\n";
-                }
+                //if (child.isOptional) {
+                    result += "            visitNodeOrToken(this, node." + child.name + ");\r\n";
+                //}
+                //else {
+                //    result += "            this.visitNodeOrToken(node." + child.name + ");\r\n";
+                //}
             }
             else if (child.type !== "SyntaxKind") {
-                if (child.isOptional) {
-                    result += "            this.visitOptionalNode(node." + child.name + ");\r\n";
-                }
-                else {
-                    result += "            this.visitNode(node." + child.name + ");\r\n";
-                }
+                //if (child.isOptional) {
+                result += "            visitNodeOrToken(this, node." + child.name + ");\r\n";
+                //}
+                //else {
+                //    result += "            this.visitNode(node." + child.name + ");\r\n";
+                //}
             }
         }
 
diff --git a/src/services/syntax/syntaxWalker.generated.ts b/src/services/syntax/syntaxWalker.generated.ts
index fe43bd25b18..21c1acefc7f 100644
--- a/src/services/syntax/syntaxWalker.generated.ts
+++ b/src/services/syntax/syntaxWalker.generated.ts
@@ -5,19 +5,6 @@ module TypeScript {
         public visitToken(token: ISyntaxToken): void {
         }
 
-        public visitNode(node: ISyntaxNode): void {
-            visitNodeOrToken(this, node);
-        }
-
-        public visitNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {
-            if (isToken(nodeOrToken)) { 
-                this.visitToken(<ISyntaxToken>nodeOrToken);
-            }
-            else {
-                this.visitNode(<ISyntaxNode>nodeOrToken);
-            }
-        }
-
         private visitOptionalToken(token: ISyntaxToken): void {
             if (token === undefined) {
                 return;
@@ -26,32 +13,16 @@ module TypeScript {
             this.visitToken(token);
         }
 
-        public visitOptionalNode(node: ISyntaxNode): void {
-            if (node === undefined) {
-                return;
-            }
-
-            this.visitNode(node);
-        }
-
-        public visitOptionalNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {
-            if (nodeOrToken === undefined) {
-                return;
-            }
-
-            this.visitNodeOrToken(nodeOrToken);
-        }
-
         public visitList(list: ISyntaxNodeOrToken[]): void {
             for (var i = 0, n = list.length; i < n; i++) {
-               this.visitNodeOrToken(list[i]);
+               visitNodeOrToken(this, list[i]);
             }
         }
 
         public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {
             for (var i = 0, n = childCount(list); i < n; i++) {
                 var item = childAt(list, i);
-                this.visitNodeOrToken(item);
+                visitNodeOrToken(this, item);
             }
         }
 
@@ -61,7 +32,7 @@ module TypeScript {
         }
 
         public visitQualifiedName(node: QualifiedNameSyntax): void {
-            this.visitNodeOrToken(node.left);
+            visitNodeOrToken(this, node.left);
             this.visitToken(node.dotToken);
             this.visitToken(node.right);
         }
@@ -73,34 +44,34 @@ module TypeScript {
         }
 
         public visitFunctionType(node: FunctionTypeSyntax): void {
-            this.visitOptionalNode(node.typeParameterList);
-            this.visitNode(node.parameterList);
+            visitNodeOrToken(this, node.typeParameterList);
+            visitNodeOrToken(this, node.parameterList);
             this.visitToken(node.equalsGreaterThanToken);
-            this.visitNodeOrToken(node.type);
+            visitNodeOrToken(this, node.type);
         }
 
         public visitArrayType(node: ArrayTypeSyntax): void {
-            this.visitNodeOrToken(node.type);
+            visitNodeOrToken(this, node.type);
             this.visitToken(node.openBracketToken);
             this.visitToken(node.closeBracketToken);
         }
 
         public visitConstructorType(node: ConstructorTypeSyntax): void {
             this.visitToken(node.newKeyword);
-            this.visitOptionalNode(node.typeParameterList);
-            this.visitNode(node.parameterList);
+            visitNodeOrToken(this, node.typeParameterList);
+            visitNodeOrToken(this, node.parameterList);
             this.visitToken(node.equalsGreaterThanToken);
-            this.visitNodeOrToken(node.type);
+            visitNodeOrToken(this, node.type);
         }
 
         public visitGenericType(node: GenericTypeSyntax): void {
-            this.visitNodeOrToken(node.name);
-            this.visitNode(node.typeArgumentList);
+            visitNodeOrToken(this, node.name);
+            visitNodeOrToken(this, node.typeArgumentList);
         }
 
         public visitTypeQuery(node: TypeQuerySyntax): void {
             this.visitToken(node.typeOfKeyword);
-            this.visitNodeOrToken(node.name);
+            visitNodeOrToken(this, node.name);
         }
 
         public visitTupleType(node: TupleTypeSyntax): void {
@@ -110,14 +81,14 @@ module TypeScript {
         }
 
         public visitUnionType(node: UnionTypeSyntax): void {
-            this.visitNodeOrToken(node.left);
+            visitNodeOrToken(this, node.left);
             this.visitToken(node.barToken);
-            this.visitNodeOrToken(node.right);
+            visitNodeOrToken(this, node.right);
         }
 
         public visitParenthesizedType(node: ParenthesizedTypeSyntax): void {
             this.visitToken(node.openParenToken);
-            this.visitNodeOrToken(node.type);
+            visitNodeOrToken(this, node.type);
             this.visitToken(node.closeParenToken);
         }
 
@@ -125,24 +96,24 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.interfaceKeyword);
             this.visitToken(node.identifier);
-            this.visitOptionalNode(node.typeParameterList);
+            visitNodeOrToken(this, node.typeParameterList);
             this.visitList(node.heritageClauses);
-            this.visitNode(node.body);
+            visitNodeOrToken(this, node.body);
         }
 
         public visitFunctionDeclaration(node: FunctionDeclarationSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.functionKeyword);
             this.visitToken(node.identifier);
-            this.visitNode(node.callSignature);
-            this.visitOptionalNode(node.block);
+            visitNodeOrToken(this, node.callSignature);
+            visitNodeOrToken(this, node.block);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitModuleDeclaration(node: ModuleDeclarationSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.moduleKeyword);
-            this.visitOptionalNodeOrToken(node.name);
+            visitNodeOrToken(this, node.name);
             this.visitOptionalToken(node.stringLiteral);
             this.visitToken(node.openBraceToken);
             this.visitList(node.moduleElements);
@@ -153,7 +124,7 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.classKeyword);
             this.visitToken(node.identifier);
-            this.visitOptionalNode(node.typeParameterList);
+            visitNodeOrToken(this, node.typeParameterList);
             this.visitList(node.heritageClauses);
             this.visitToken(node.openBraceToken);
             this.visitList(node.classElements);
@@ -174,7 +145,7 @@ module TypeScript {
             this.visitToken(node.importKeyword);
             this.visitToken(node.identifier);
             this.visitToken(node.equalsToken);
-            this.visitNodeOrToken(node.moduleReference);
+            visitNodeOrToken(this, node.moduleReference);
             this.visitOptionalToken(node.semicolonToken);
         }
 
@@ -188,28 +159,28 @@ module TypeScript {
         public visitMemberFunctionDeclaration(node: MemberFunctionDeclarationSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.propertyName);
-            this.visitNode(node.callSignature);
-            this.visitOptionalNode(node.block);
+            visitNodeOrToken(this, node.callSignature);
+            visitNodeOrToken(this, node.block);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitMemberVariableDeclaration(node: MemberVariableDeclarationSyntax): void {
             this.visitList(node.modifiers);
-            this.visitNode(node.variableDeclarator);
+            visitNodeOrToken(this, node.variableDeclarator);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitConstructorDeclaration(node: ConstructorDeclarationSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.constructorKeyword);
-            this.visitNode(node.callSignature);
-            this.visitOptionalNode(node.block);
+            visitNodeOrToken(this, node.callSignature);
+            visitNodeOrToken(this, node.block);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitIndexMemberDeclaration(node: IndexMemberDeclarationSyntax): void {
             this.visitList(node.modifiers);
-            this.visitNode(node.indexSignature);
+            visitNodeOrToken(this, node.indexSignature);
             this.visitOptionalToken(node.semicolonToken);
         }
 
@@ -217,46 +188,46 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.getKeyword);
             this.visitToken(node.propertyName);
-            this.visitNode(node.callSignature);
-            this.visitNode(node.block);
+            visitNodeOrToken(this, node.callSignature);
+            visitNodeOrToken(this, node.block);
         }
 
         public visitSetAccessor(node: SetAccessorSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.setKeyword);
             this.visitToken(node.propertyName);
-            this.visitNode(node.callSignature);
-            this.visitNode(node.block);
+            visitNodeOrToken(this, node.callSignature);
+            visitNodeOrToken(this, node.block);
         }
 
         public visitPropertySignature(node: PropertySignatureSyntax): void {
             this.visitToken(node.propertyName);
             this.visitOptionalToken(node.questionToken);
-            this.visitOptionalNode(node.typeAnnotation);
+            visitNodeOrToken(this, node.typeAnnotation);
         }
 
         public visitCallSignature(node: CallSignatureSyntax): void {
-            this.visitOptionalNode(node.typeParameterList);
-            this.visitNode(node.parameterList);
-            this.visitOptionalNode(node.typeAnnotation);
+            visitNodeOrToken(this, node.typeParameterList);
+            visitNodeOrToken(this, node.parameterList);
+            visitNodeOrToken(this, node.typeAnnotation);
         }
 
         public visitConstructSignature(node: ConstructSignatureSyntax): void {
             this.visitToken(node.newKeyword);
-            this.visitNode(node.callSignature);
+            visitNodeOrToken(this, node.callSignature);
         }
 
         public visitIndexSignature(node: IndexSignatureSyntax): void {
             this.visitToken(node.openBracketToken);
             this.visitSeparatedList(node.parameters);
             this.visitToken(node.closeBracketToken);
-            this.visitOptionalNode(node.typeAnnotation);
+            visitNodeOrToken(this, node.typeAnnotation);
         }
 
         public visitMethodSignature(node: MethodSignatureSyntax): void {
             this.visitToken(node.propertyName);
             this.visitOptionalToken(node.questionToken);
-            this.visitNode(node.callSignature);
+            visitNodeOrToken(this, node.callSignature);
         }
 
         public visitBlock(node: BlockSyntax): void {
@@ -268,33 +239,33 @@ module TypeScript {
         public visitIfStatement(node: IfStatementSyntax): void {
             this.visitToken(node.ifKeyword);
             this.visitToken(node.openParenToken);
-            this.visitNodeOrToken(node.condition);
+            visitNodeOrToken(this, node.condition);
             this.visitToken(node.closeParenToken);
-            this.visitNodeOrToken(node.statement);
-            this.visitOptionalNode(node.elseClause);
+            visitNodeOrToken(this, node.statement);
+            visitNodeOrToken(this, node.elseClause);
         }
 
         public visitVariableStatement(node: VariableStatementSyntax): void {
             this.visitList(node.modifiers);
-            this.visitNode(node.variableDeclaration);
+            visitNodeOrToken(this, node.variableDeclaration);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitExpressionStatement(node: ExpressionStatementSyntax): void {
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitReturnStatement(node: ReturnStatementSyntax): void {
             this.visitToken(node.returnKeyword);
-            this.visitOptionalNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitSwitchStatement(node: SwitchStatementSyntax): void {
             this.visitToken(node.switchKeyword);
             this.visitToken(node.openParenToken);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitToken(node.closeParenToken);
             this.visitToken(node.openBraceToken);
             this.visitList(node.switchClauses);
@@ -316,25 +287,25 @@ module TypeScript {
         public visitForStatement(node: ForStatementSyntax): void {
             this.visitToken(node.forKeyword);
             this.visitToken(node.openParenToken);
-            this.visitOptionalNode(node.variableDeclaration);
-            this.visitOptionalNodeOrToken(node.initializer);
+            visitNodeOrToken(this, node.variableDeclaration);
+            visitNodeOrToken(this, node.initializer);
             this.visitToken(node.firstSemicolonToken);
-            this.visitOptionalNodeOrToken(node.condition);
+            visitNodeOrToken(this, node.condition);
             this.visitToken(node.secondSemicolonToken);
-            this.visitOptionalNodeOrToken(node.incrementor);
+            visitNodeOrToken(this, node.incrementor);
             this.visitToken(node.closeParenToken);
-            this.visitNodeOrToken(node.statement);
+            visitNodeOrToken(this, node.statement);
         }
 
         public visitForInStatement(node: ForInStatementSyntax): void {
             this.visitToken(node.forKeyword);
             this.visitToken(node.openParenToken);
-            this.visitOptionalNode(node.variableDeclaration);
-            this.visitOptionalNodeOrToken(node.left);
+            visitNodeOrToken(this, node.variableDeclaration);
+            visitNodeOrToken(this, node.left);
             this.visitToken(node.inKeyword);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitToken(node.closeParenToken);
-            this.visitNodeOrToken(node.statement);
+            visitNodeOrToken(this, node.statement);
         }
 
         public visitEmptyStatement(node: EmptyStatementSyntax): void {
@@ -343,37 +314,37 @@ module TypeScript {
 
         public visitThrowStatement(node: ThrowStatementSyntax): void {
             this.visitToken(node.throwKeyword);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitWhileStatement(node: WhileStatementSyntax): void {
             this.visitToken(node.whileKeyword);
             this.visitToken(node.openParenToken);
-            this.visitNodeOrToken(node.condition);
+            visitNodeOrToken(this, node.condition);
             this.visitToken(node.closeParenToken);
-            this.visitNodeOrToken(node.statement);
+            visitNodeOrToken(this, node.statement);
         }
 
         public visitTryStatement(node: TryStatementSyntax): void {
             this.visitToken(node.tryKeyword);
-            this.visitNode(node.block);
-            this.visitOptionalNode(node.catchClause);
-            this.visitOptionalNode(node.finallyClause);
+            visitNodeOrToken(this, node.block);
+            visitNodeOrToken(this, node.catchClause);
+            visitNodeOrToken(this, node.finallyClause);
         }
 
         public visitLabeledStatement(node: LabeledStatementSyntax): void {
             this.visitToken(node.identifier);
             this.visitToken(node.colonToken);
-            this.visitNodeOrToken(node.statement);
+            visitNodeOrToken(this, node.statement);
         }
 
         public visitDoStatement(node: DoStatementSyntax): void {
             this.visitToken(node.doKeyword);
-            this.visitNodeOrToken(node.statement);
+            visitNodeOrToken(this, node.statement);
             this.visitToken(node.whileKeyword);
             this.visitToken(node.openParenToken);
-            this.visitNodeOrToken(node.condition);
+            visitNodeOrToken(this, node.condition);
             this.visitToken(node.closeParenToken);
             this.visitOptionalToken(node.semicolonToken);
         }
@@ -386,59 +357,59 @@ module TypeScript {
         public visitWithStatement(node: WithStatementSyntax): void {
             this.visitToken(node.withKeyword);
             this.visitToken(node.openParenToken);
-            this.visitNodeOrToken(node.condition);
+            visitNodeOrToken(this, node.condition);
             this.visitToken(node.closeParenToken);
-            this.visitNodeOrToken(node.statement);
+            visitNodeOrToken(this, node.statement);
         }
 
         public visitPrefixUnaryExpression(node: PrefixUnaryExpressionSyntax): void {
             this.visitToken(node.operatorToken);
-            this.visitNodeOrToken(node.operand);
+            visitNodeOrToken(this, node.operand);
         }
 
         public visitDeleteExpression(node: DeleteExpressionSyntax): void {
             this.visitToken(node.deleteKeyword);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
         }
 
         public visitTypeOfExpression(node: TypeOfExpressionSyntax): void {
             this.visitToken(node.typeOfKeyword);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
         }
 
         public visitVoidExpression(node: VoidExpressionSyntax): void {
             this.visitToken(node.voidKeyword);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
         }
 
         public visitConditionalExpression(node: ConditionalExpressionSyntax): void {
-            this.visitNodeOrToken(node.condition);
+            visitNodeOrToken(this, node.condition);
             this.visitToken(node.questionToken);
-            this.visitNodeOrToken(node.whenTrue);
+            visitNodeOrToken(this, node.whenTrue);
             this.visitToken(node.colonToken);
-            this.visitNodeOrToken(node.whenFalse);
+            visitNodeOrToken(this, node.whenFalse);
         }
 
         public visitBinaryExpression(node: BinaryExpressionSyntax): void {
-            this.visitNodeOrToken(node.left);
+            visitNodeOrToken(this, node.left);
             this.visitToken(node.operatorToken);
-            this.visitNodeOrToken(node.right);
+            visitNodeOrToken(this, node.right);
         }
 
         public visitPostfixUnaryExpression(node: PostfixUnaryExpressionSyntax): void {
-            this.visitNodeOrToken(node.operand);
+            visitNodeOrToken(this, node.operand);
             this.visitToken(node.operatorToken);
         }
 
         public visitMemberAccessExpression(node: MemberAccessExpressionSyntax): void {
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitToken(node.dotToken);
             this.visitToken(node.name);
         }
 
         public visitInvocationExpression(node: InvocationExpressionSyntax): void {
-            this.visitNodeOrToken(node.expression);
-            this.visitNode(node.argumentList);
+            visitNodeOrToken(this, node.expression);
+            visitNodeOrToken(this, node.argumentList);
         }
 
         public visitArrayLiteralExpression(node: ArrayLiteralExpressionSyntax): void {
@@ -455,49 +426,49 @@ module TypeScript {
 
         public visitObjectCreationExpression(node: ObjectCreationExpressionSyntax): void {
             this.visitToken(node.newKeyword);
-            this.visitNodeOrToken(node.expression);
-            this.visitOptionalNode(node.argumentList);
+            visitNodeOrToken(this, node.expression);
+            visitNodeOrToken(this, node.argumentList);
         }
 
         public visitParenthesizedExpression(node: ParenthesizedExpressionSyntax): void {
             this.visitToken(node.openParenToken);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitToken(node.closeParenToken);
         }
 
         public visitParenthesizedArrowFunctionExpression(node: ParenthesizedArrowFunctionExpressionSyntax): void {
-            this.visitNode(node.callSignature);
+            visitNodeOrToken(this, node.callSignature);
             this.visitToken(node.equalsGreaterThanToken);
-            this.visitOptionalNode(node.block);
-            this.visitOptionalNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.block);
+            visitNodeOrToken(this, node.expression);
         }
 
         public visitSimpleArrowFunctionExpression(node: SimpleArrowFunctionExpressionSyntax): void {
-            this.visitNode(node.parameter);
+            visitNodeOrToken(this, node.parameter);
             this.visitToken(node.equalsGreaterThanToken);
-            this.visitOptionalNode(node.block);
-            this.visitOptionalNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.block);
+            visitNodeOrToken(this, node.expression);
         }
 
         public visitCastExpression(node: CastExpressionSyntax): void {
             this.visitToken(node.lessThanToken);
-            this.visitNodeOrToken(node.type);
+            visitNodeOrToken(this, node.type);
             this.visitToken(node.greaterThanToken);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
         }
 
         public visitElementAccessExpression(node: ElementAccessExpressionSyntax): void {
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitToken(node.openBracketToken);
-            this.visitNodeOrToken(node.argumentExpression);
+            visitNodeOrToken(this, node.argumentExpression);
             this.visitToken(node.closeBracketToken);
         }
 
         public visitFunctionExpression(node: FunctionExpressionSyntax): void {
             this.visitToken(node.functionKeyword);
             this.visitOptionalToken(node.identifier);
-            this.visitNode(node.callSignature);
-            this.visitNode(node.block);
+            visitNodeOrToken(this, node.callSignature);
+            visitNodeOrToken(this, node.block);
         }
 
         public visitOmittedExpression(node: OmittedExpressionSyntax): void {
@@ -510,12 +481,12 @@ module TypeScript {
 
         public visitVariableDeclarator(node: VariableDeclaratorSyntax): void {
             this.visitToken(node.propertyName);
-            this.visitOptionalNode(node.typeAnnotation);
-            this.visitOptionalNode(node.equalsValueClause);
+            visitNodeOrToken(this, node.typeAnnotation);
+            visitNodeOrToken(this, node.equalsValueClause);
         }
 
         public visitArgumentList(node: ArgumentListSyntax): void {
-            this.visitOptionalNode(node.typeArgumentList);
+            visitNodeOrToken(this, node.typeArgumentList);
             this.visitToken(node.openParenToken);
             this.visitSeparatedList(node.arguments);
             this.visitToken(node.closeParenToken);
@@ -546,12 +517,12 @@ module TypeScript {
 
         public visitEqualsValueClause(node: EqualsValueClauseSyntax): void {
             this.visitToken(node.equalsToken);
-            this.visitNodeOrToken(node.value);
+            visitNodeOrToken(this, node.value);
         }
 
         public visitCaseSwitchClause(node: CaseSwitchClauseSyntax): void {
             this.visitToken(node.caseKeyword);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
             this.visitToken(node.colonToken);
             this.visitList(node.statements);
         }
@@ -564,43 +535,43 @@ module TypeScript {
 
         public visitElseClause(node: ElseClauseSyntax): void {
             this.visitToken(node.elseKeyword);
-            this.visitNodeOrToken(node.statement);
+            visitNodeOrToken(this, node.statement);
         }
 
         public visitCatchClause(node: CatchClauseSyntax): void {
             this.visitToken(node.catchKeyword);
             this.visitToken(node.openParenToken);
             this.visitToken(node.identifier);
-            this.visitOptionalNode(node.typeAnnotation);
+            visitNodeOrToken(this, node.typeAnnotation);
             this.visitToken(node.closeParenToken);
-            this.visitNode(node.block);
+            visitNodeOrToken(this, node.block);
         }
 
         public visitFinallyClause(node: FinallyClauseSyntax): void {
             this.visitToken(node.finallyKeyword);
-            this.visitNode(node.block);
+            visitNodeOrToken(this, node.block);
         }
 
         public visitTypeParameter(node: TypeParameterSyntax): void {
             this.visitToken(node.identifier);
-            this.visitOptionalNode(node.constraint);
+            visitNodeOrToken(this, node.constraint);
         }
 
         public visitConstraint(node: ConstraintSyntax): void {
             this.visitToken(node.extendsKeyword);
-            this.visitNodeOrToken(node.typeOrExpression);
+            visitNodeOrToken(this, node.typeOrExpression);
         }
 
         public visitSimplePropertyAssignment(node: SimplePropertyAssignmentSyntax): void {
             this.visitToken(node.propertyName);
             this.visitToken(node.colonToken);
-            this.visitNodeOrToken(node.expression);
+            visitNodeOrToken(this, node.expression);
         }
 
         public visitFunctionPropertyAssignment(node: FunctionPropertyAssignmentSyntax): void {
             this.visitToken(node.propertyName);
-            this.visitNode(node.callSignature);
-            this.visitNode(node.block);
+            visitNodeOrToken(this, node.callSignature);
+            visitNodeOrToken(this, node.block);
         }
 
         public visitParameter(node: ParameterSyntax): void {
@@ -608,18 +579,18 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.identifier);
             this.visitOptionalToken(node.questionToken);
-            this.visitOptionalNode(node.typeAnnotation);
-            this.visitOptionalNode(node.equalsValueClause);
+            visitNodeOrToken(this, node.typeAnnotation);
+            visitNodeOrToken(this, node.equalsValueClause);
         }
 
         public visitEnumElement(node: EnumElementSyntax): void {
             this.visitToken(node.propertyName);
-            this.visitOptionalNode(node.equalsValueClause);
+            visitNodeOrToken(this, node.equalsValueClause);
         }
 
         public visitTypeAnnotation(node: TypeAnnotationSyntax): void {
             this.visitToken(node.colonToken);
-            this.visitNodeOrToken(node.type);
+            visitNodeOrToken(this, node.type);
         }
 
         public visitExternalModuleReference(node: ExternalModuleReferenceSyntax): void {
@@ -630,7 +601,7 @@ module TypeScript {
         }
 
         public visitModuleNameModuleReference(node: ModuleNameModuleReferenceSyntax): void {
-            this.visitNodeOrToken(node.moduleName);
+            visitNodeOrToken(this, node.moduleName);
         }
     }
 }
\ No newline at end of file