diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 83cc54e1acc..9f612e11673 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -427,7 +427,7 @@ module ts {
                 if (result.flags & SymbolFlags.BlockScopedVariable) {
                     // Block-scoped variables cannot be used before their definition
                     var declaration = forEach(result.declarations, d => d.flags & NodeFlags.BlockScoped ? d : undefined);
-                    Debug.assert(declaration, "Block-scoped variable declaration is undefined");
+                    Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined");
                     var declarationSourceFile = getSourceFileOfNode(declaration);
                     var referenceSourceFile = getSourceFileOfNode(errorLocation);
                     if (declarationSourceFile === referenceSourceFile) {
@@ -472,7 +472,7 @@ module ts {
         function getSymbolOfPartOfRightHandSideOfImport(entityName: EntityName, importDeclaration?: ImportDeclaration): Symbol {
             if (!importDeclaration) {
                 importDeclaration = getAncestor(entityName, SyntaxKind.ImportDeclaration);
-                Debug.assert(importDeclaration);
+                Debug.assert(importDeclaration !== undefined);
             }
             // There are three things we might try to look for. In the following examples,
             // the search term is enclosed in |...|:
@@ -3334,7 +3334,6 @@ module ts {
                 }
                 if (reportErrors) {
                     headMessage = headMessage || Diagnostics.Type_0_is_not_assignable_to_type_1;
-                    Debug.assert(headMessage);
                     reportError(headMessage, typeToString(source), typeToString(target));
                 }
                 return Ternary.False;
@@ -4912,7 +4911,7 @@ module ts {
             }
             return createArrayType(getUnionType(elementTypes));
         }
-
+        
         function isNumericName(name: string) {
             // The intent of numeric names is that
             //     - they are names with text in a numeric form, and that
@@ -4937,7 +4936,7 @@ module ts {
             // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively.
             return (+name).toString() === name;
         }
-
+        
         function checkObjectLiteral(node: ObjectLiteral, contextualMapper?: TypeMapper): Type {
             var members = node.symbol.members;
             var properties: SymbolTable = {};
@@ -5660,6 +5659,13 @@ module ts {
             return getReturnTypeOfSignature(signature);
         }
 
+        function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {
+            // TODO (drosen): Make sure substitutions are assignable to the tag's arguments.
+            checkExpression(node.tag);
+            checkExpression(node.template);
+            return anyType;
+        }
+
         function checkTypeAssertion(node: TypeAssertion): Type {
             var exprType = checkExpression(node.operand);
             var targetType = getTypeFromTypeNode(node.type);
@@ -6170,6 +6176,19 @@ module ts {
             return getUnionType([type1, type2]);
         }
 
+        function checkTemplateExpression(node: TemplateExpression): Type {
+            // We just want to check each expressions, but we are unconcerned with
+            // the type of each expression, as any value may be coerced into a string.
+            // It is worth asking whether this is what we really want though.
+            // A place where we actually *are* concerned with the expressions' types are
+            // in tagged templates.
+            forEach((<TemplateExpression>node).templateSpans, templateSpan => {
+                checkExpression(templateSpan.expression);
+            });
+
+            return stringType;
+        }
+
         function checkExpressionWithContextualType(node: Expression, contextualType: Type, contextualMapper?: TypeMapper): Type {
             var saveContextualType = node.contextualType;
             node.contextualType = contextualType;
@@ -6223,7 +6242,10 @@ module ts {
                     return booleanType;
                 case SyntaxKind.NumericLiteral:
                     return numberType;
+                case SyntaxKind.TemplateExpression:
+                    return checkTemplateExpression(<TemplateExpression>node);
                 case SyntaxKind.StringLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
                     return stringType;
                 case SyntaxKind.RegularExpressionLiteral:
                     return globalRegExpType;
@@ -6240,6 +6262,8 @@ module ts {
                 case SyntaxKind.CallExpression:
                 case SyntaxKind.NewExpression:
                     return checkCallExpression(<CallExpression>node);
+                case SyntaxKind.TaggedTemplateExpression:
+                    return checkTaggedTemplateExpression(<TaggedTemplateExpression>node);
                 case SyntaxKind.TypeAssertion:
                     return checkTypeAssertion(<TypeAssertion>node);
                 case SyntaxKind.ParenExpression:
@@ -7549,17 +7573,17 @@ module ts {
                             errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
                         }
                         else {
-                            Debug.assert(derived.flags & SymbolFlags.Property);
+                            Debug.assert((derived.flags & SymbolFlags.Property) !== 0);
                             errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property;
                         }
                     }
                     else if (base.flags & SymbolFlags.Property) {
-                        Debug.assert(derived.flags & SymbolFlags.Method);
+                        Debug.assert((derived.flags & SymbolFlags.Method) !== 0);
                         errorMessage = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
                     }
                     else {
-                        Debug.assert(base.flags & SymbolFlags.Accessor);
-                        Debug.assert(derived.flags & SymbolFlags.Method);
+                        Debug.assert((base.flags & SymbolFlags.Accessor) !== 0);
+                        Debug.assert((derived.flags & SymbolFlags.Method) !== 0);
                         errorMessage = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
                     }
 
@@ -8016,6 +8040,7 @@ module ts {
                 case SyntaxKind.IndexedAccess:
                 case SyntaxKind.CallExpression:
                 case SyntaxKind.NewExpression:
+                case SyntaxKind.TaggedTemplateExpression:
                 case SyntaxKind.TypeAssertion:
                 case SyntaxKind.ParenExpression:
                 case SyntaxKind.PrefixOperator:
@@ -8293,6 +8318,9 @@ module ts {
                         case SyntaxKind.CallExpression:
                         case SyntaxKind.NewExpression:
                             return (<CallExpression>parent).typeArguments && (<CallExpression>parent).typeArguments.indexOf(node) >= 0;
+                        case SyntaxKind.TaggedTemplateExpression:
+                            // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments.
+                            return false;
                     }
             }
 
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index b233d3575b3..6fd07fe4a6a 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -19,6 +19,12 @@ module ts {
         [index: string]: T;
     }
 
+    export enum Comparison {
+        LessThan    = -1,
+        EqualTo     = 0,
+        GreaterThan = 1
+    }
+
     export interface StringSet extends Map<any> { }
 
     export function forEach<T, U>(array: T[], callback: (element: T) => U): U {
@@ -93,6 +99,7 @@ module ts {
     export function concatenate<T>(array1: T[], array2: T[]): T[] {
         if (!array2 || !array2.length) return array1;
         if (!array1 || !array1.length) return array2;
+
         return array1.concat(array2);
     }
 
@@ -326,11 +333,11 @@ module ts {
         };
     }
 
-    export function compareValues<T>(a: T, b: T): number {
-        if (a === b) return 0;
-        if (a === undefined) return -1;
-        if (b === undefined) return 1;
-        return a < b ? -1 : 1;
+    export function compareValues<T>(a: T, b: T): Comparison {
+        if (a === b) return Comparison.EqualTo;
+        if (a === undefined) return Comparison.LessThan;
+        if (b === undefined) return Comparison.GreaterThan;
+        return a < b ? Comparison.LessThan : Comparison.GreaterThan;
     }
 
     function getDiagnosticFilename(diagnostic: Diagnostic): string {
@@ -355,7 +362,7 @@ module ts {
         var previousDiagnostic = diagnostics[0];
         for (var i = 1; i < diagnostics.length; i++) {
             var currentDiagnostic = diagnostics[i];
-            var isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === 0;
+            var isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === Comparison.EqualTo;
             if (!isDupe) {
                 newDiagnostics.push(currentDiagnostic);
                 previousDiagnostic = currentDiagnostic;
@@ -644,7 +651,7 @@ module ts {
             return currentAssertionLevel >= level;
         }
 
-        export function assert(expression: any, message?: string, verboseDebugInfo?: () => string): void {
+        export function assert(expression: boolean, message?: string, verboseDebugInfo?: () => string): void {
             if (!expression) {
                 var verboseDebugString = "";
                 if (verboseDebugInfo) {
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index 82567f70ca6..7ab19bd5074 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -121,6 +121,8 @@ module ts {
         const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: DiagnosticCategory.Error, key: "'const' declarations can only be declared inside a block." },
         let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block." },
         Aliased_type_cannot_be_an_object_type_literal_Use_an_interface_declaration_instead: { code: 1158, category: DiagnosticCategory.Error, key: "Aliased type cannot be an object type literal. Use an interface declaration instead." },
+        Invalid_template_literal_expected: { code: 1159, category: DiagnosticCategory.Error, key: "Invalid template literal; expected '}'" },
+        Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1160, category: DiagnosticCategory.Error, key: "Tagged templates are only available when targeting ECMAScript 6 and higher." },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 72d7c79a024..3e380ea5a67 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -475,6 +475,14 @@
         "category": "Error",
         "code": 1158
     },
+    "Invalid template literal; expected '}'": {
+        "category": "Error",
+        "code": 1159
+    },
+    "Tagged templates are only available when targeting ECMAScript 6 and higher.": {
+        "category": "Error",
+        "code": 1160
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index bc27520d87c..782d22a0bf4 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -786,14 +786,123 @@ module ts {
                 }
             }
 
-            function emitLiteral(node: LiteralExpression) {
-                var text = getSourceTextOfLocalNode(node);
-                if (node.kind === SyntaxKind.StringLiteral && compilerOptions.sourceMap) {
+            function emitLiteral(node: LiteralExpression): void {
+                var text = getLiteralText();
+
+                if (compilerOptions.sourceMap && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {
                     writer.writeLiteral(text);
                 }
                 else {
                     write(text);
                 }
+
+                function getLiteralText() {
+                    if (compilerOptions.target < ScriptTarget.ES6 && isTemplateLiteralKind(node.kind)) {
+                        return getTemplateLiteralAsStringLiteral(node)
+                    }
+
+                    return getSourceTextOfLocalNode(node);
+                }
+            }
+
+            function getTemplateLiteralAsStringLiteral(node: LiteralExpression): string {
+                return '"' + escapeString(node.text) + '"';
+            }
+            
+            function emitTemplateExpression(node: TemplateExpression): void {
+                // In ES6 mode and above, we can simply emit each portion of a template in order, but in
+                // ES3 & ES5 we must convert the template expression into a series of string concatenations.
+                if (compilerOptions.target >= ScriptTarget.ES6) {
+                    forEachChild(node, emit);
+                    return;
+                }
+
+                Debug.assert(node.parent.kind !== SyntaxKind.TaggedTemplateExpression);
+
+                var templateNeedsParens = isExpression(node.parent)
+                    && node.parent.kind !== SyntaxKind.ParenExpression
+                    && comparePrecedenceToBinaryPlus(node.parent) !== Comparison.LessThan;
+
+                if (templateNeedsParens) {
+                    write("(");
+                }
+
+                emitLiteral(node.head);
+
+                forEach(node.templateSpans, templateSpan => {
+                    // Check if the expression has operands and binds its operands less closely than binary '+'.
+                    // If it does, we need to wrap the expression in parentheses. Otherwise, something like
+                    //    `abc${ 1 << 2}`
+                    // becomes
+                    //    "abc" + 1 << 2 + ""
+                    // which is really
+                    //    ("abc" + 1) << (2 + "")
+                    // rather than
+                    //    "abc" + (1 << 2) + ""
+                    var needsParens = templateSpan.expression.kind !== SyntaxKind.ParenExpression
+                        && comparePrecedenceToBinaryPlus(templateSpan.expression) !== Comparison.GreaterThan;
+
+                    write(" + ");
+
+                    if (needsParens) {
+                        write("(");
+                    }
+                    emit(templateSpan.expression);
+                    if (needsParens) {
+                        write(")");
+                    }
+
+                    // Only emit if the literal is non-empty.
+                    // The binary '+' operator is left-associative, so the first string concatenation will force
+                    // the result up to this point to be a string. Emitting a '+ ""' has no semantic effect.
+                    if (templateSpan.literal.text.length !== 0) {
+                        write(" + ")
+                        emitLiteral(templateSpan.literal);
+                    }
+                });
+                
+                if (templateNeedsParens) {
+                    write(")");
+                }
+
+                /**
+                 * Returns whether the expression has lesser, greater,
+                 * or equal precedence to the binary '+' operator
+                 */
+                function comparePrecedenceToBinaryPlus(expression: Expression): Comparison {
+                    // All binary expressions have lower precedence than '+' apart from '*', '/', and '%'.
+                    // All unary operators have a higher precedence apart from yield.
+                    // Arrow functions and conditionals have a lower precedence, 
+                    // although we convert the former into regular function expressions in ES5 mode,
+                    // and in ES6 mode this function won't get called anyway.
+                    // 
+                    // TODO (drosen): Note that we need to account for the upcoming 'yield' and
+                    //                spread ('...') unary operators that are anticipated for ES6.
+                    Debug.assert(compilerOptions.target <= ScriptTarget.ES5);
+                    switch (expression.kind) {
+                        case SyntaxKind.BinaryExpression:
+                            switch ((<BinaryExpression>expression).operator) {
+                                case SyntaxKind.AsteriskToken:
+                                case SyntaxKind.SlashToken:
+                                case SyntaxKind.PercentToken:
+                                    return Comparison.GreaterThan;
+                                case SyntaxKind.PlusToken:
+                                    return Comparison.EqualTo;
+                                default:
+                                    return Comparison.LessThan;
+                            }
+                        case SyntaxKind.ConditionalExpression:
+                            return Comparison.LessThan;
+                        default:
+                            return Comparison.GreaterThan;
+                    }
+                }
+
+            }
+
+            function emitTemplateSpan(span: TemplateSpan) {
+                emit(span.expression);
+                emit(span.literal);
             }
 
             // This function specifically handles numeric/string literals for enum and accessor 'identifiers'.
@@ -977,6 +1086,13 @@ module ts {
                 }
             }
 
+            function emitTaggedTemplateExpression(node: TaggedTemplateExpression): void {
+                Debug.assert(compilerOptions.target >= ScriptTarget.ES6, "Trying to emit a tagged template in pre-ES6 mode.");
+                emit(node.tag);
+                write(" ");
+                emit(node.template);
+            }
+
             function emitParenExpression(node: ParenExpression) {
                 if (node.expression.kind === SyntaxKind.TypeAssertion) {
                     var operand = (<TypeAssertion>node.expression).operand;
@@ -2085,7 +2201,15 @@ module ts {
                     case SyntaxKind.NumericLiteral:
                     case SyntaxKind.StringLiteral:
                     case SyntaxKind.RegularExpressionLiteral:
+                    case SyntaxKind.NoSubstitutionTemplateLiteral:
+                    case SyntaxKind.TemplateHead:
+                    case SyntaxKind.TemplateMiddle:
+                    case SyntaxKind.TemplateTail:
                         return emitLiteral(<LiteralExpression>node);
+                    case SyntaxKind.TemplateExpression:
+                        return emitTemplateExpression(<TemplateExpression>node);
+                    case SyntaxKind.TemplateSpan:
+                        return emitTemplateSpan(<TemplateSpan>node);
                     case SyntaxKind.QualifiedName:
                         return emitPropertyAccess(<QualifiedName>node);
                     case SyntaxKind.ArrayLiteral:
@@ -2102,6 +2226,8 @@ module ts {
                         return emitCallExpression(<CallExpression>node);
                     case SyntaxKind.NewExpression:
                         return emitNewExpression(<NewExpression>node);
+                    case SyntaxKind.TaggedTemplateExpression:
+                        return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
                     case SyntaxKind.TypeAssertion:
                         return emit((<TypeAssertion>node).operand);
                     case SyntaxKind.ParenExpression:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 6c2207a08d2..0c5af3660a2 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -67,77 +67,6 @@ module ts {
         return identifier.kind === SyntaxKind.Missing ? "(Missing)" : getTextOfNode(identifier);
     }
 
-    export function isExpression(node: Node): boolean {
-        switch (node.kind) {
-            case SyntaxKind.ThisKeyword:
-            case SyntaxKind.SuperKeyword:
-            case SyntaxKind.NullKeyword:
-            case SyntaxKind.TrueKeyword:
-            case SyntaxKind.FalseKeyword:
-            case SyntaxKind.RegularExpressionLiteral:
-            case SyntaxKind.ArrayLiteral:
-            case SyntaxKind.ObjectLiteral:
-            case SyntaxKind.PropertyAccess:
-            case SyntaxKind.IndexedAccess:
-            case SyntaxKind.CallExpression:
-            case SyntaxKind.NewExpression:
-            case SyntaxKind.TypeAssertion:
-            case SyntaxKind.ParenExpression:
-            case SyntaxKind.FunctionExpression:
-            case SyntaxKind.ArrowFunction:
-            case SyntaxKind.PrefixOperator:
-            case SyntaxKind.PostfixOperator:
-            case SyntaxKind.BinaryExpression:
-            case SyntaxKind.ConditionalExpression:
-            case SyntaxKind.OmittedExpression:
-                return true;
-            case SyntaxKind.QualifiedName:
-                while (node.parent.kind === SyntaxKind.QualifiedName) node = node.parent;
-                return node.parent.kind === SyntaxKind.TypeQuery;
-            case SyntaxKind.Identifier:
-                if (node.parent.kind === SyntaxKind.TypeQuery) {
-                    return true;
-                }
-            // Fall through
-            case SyntaxKind.NumericLiteral:
-            case SyntaxKind.StringLiteral:
-                var parent = node.parent;
-                switch (parent.kind) {
-                    case SyntaxKind.VariableDeclaration:
-                    case SyntaxKind.Parameter:
-                    case SyntaxKind.Property:
-                    case SyntaxKind.EnumMember:
-                    case SyntaxKind.PropertyAssignment:
-                        return (<VariableDeclaration>parent).initializer === node;
-                    case SyntaxKind.ExpressionStatement:
-                    case SyntaxKind.IfStatement:
-                    case SyntaxKind.DoStatement:
-                    case SyntaxKind.WhileStatement:
-                    case SyntaxKind.ReturnStatement:
-                    case SyntaxKind.WithStatement:
-                    case SyntaxKind.SwitchStatement:
-                    case SyntaxKind.CaseClause:
-                    case SyntaxKind.ThrowStatement:
-                    case SyntaxKind.SwitchStatement:
-                        return (<ExpressionStatement>parent).expression === node;
-                    case SyntaxKind.ForStatement:
-                        return (<ForStatement>parent).initializer === node ||
-                            (<ForStatement>parent).condition === node ||
-                            (<ForStatement>parent).iterator === node;
-                    case SyntaxKind.ForInStatement:
-                        return (<ForInStatement>parent).variable === node ||
-                            (<ForInStatement>parent).expression === node;
-                    case SyntaxKind.TypeAssertion:
-                        return node === (<TypeAssertion>parent).operand;
-                    default:
-                        if (isExpression(parent)) {
-                            return true;
-                        }
-                }
-        }
-        return false;
-    }
-
     export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic {
         node = getErrorSpanForNode(node);
         var file = getSourceFileOfNode(node);
@@ -315,6 +244,9 @@ module ts {
                 return child((<CallExpression>node).func) ||
                     children((<CallExpression>node).typeArguments) ||
                     children((<CallExpression>node).arguments);
+            case SyntaxKind.TaggedTemplateExpression:
+                return child((<TaggedTemplateExpression>node).tag) ||
+                    child((<TaggedTemplateExpression>node).template);
             case SyntaxKind.TypeAssertion:
                 return child((<TypeAssertion>node).type) ||
                     child((<TypeAssertion>node).operand);
@@ -422,6 +354,10 @@ module ts {
                     child((<ImportDeclaration>node).externalModuleName);
             case SyntaxKind.ExportAssignment:
                 return child((<ExportAssignment>node).exportName);
+            case SyntaxKind.TemplateExpression:
+                return child((<TemplateExpression>node).head) || children((<TemplateExpression>node).templateSpans);
+            case SyntaxKind.TemplateSpan:
+                return child((<TemplateSpan>node).expression) || child((<TemplateSpan>node).literal);
         }
     }
 
@@ -526,10 +462,96 @@ module ts {
         }
     }
 
+    export function isExpression(node: Node): boolean {
+        switch (node.kind) {
+            case SyntaxKind.ThisKeyword:
+            case SyntaxKind.SuperKeyword:
+            case SyntaxKind.NullKeyword:
+            case SyntaxKind.TrueKeyword:
+            case SyntaxKind.FalseKeyword:
+            case SyntaxKind.RegularExpressionLiteral:
+            case SyntaxKind.ArrayLiteral:
+            case SyntaxKind.ObjectLiteral:
+            case SyntaxKind.PropertyAccess:
+            case SyntaxKind.IndexedAccess:
+            case SyntaxKind.CallExpression:
+            case SyntaxKind.NewExpression:
+            case SyntaxKind.TaggedTemplateExpression:
+            case SyntaxKind.TypeAssertion:
+            case SyntaxKind.ParenExpression:
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.PrefixOperator:
+            case SyntaxKind.PostfixOperator:
+            case SyntaxKind.BinaryExpression:
+            case SyntaxKind.ConditionalExpression:
+            case SyntaxKind.TemplateExpression:
+            case SyntaxKind.OmittedExpression:
+                return true;
+            case SyntaxKind.QualifiedName:
+                while (node.parent.kind === SyntaxKind.QualifiedName) node = node.parent;
+                return node.parent.kind === SyntaxKind.TypeQuery;
+            case SyntaxKind.Identifier:
+                if (node.parent.kind === SyntaxKind.TypeQuery) {
+                    return true;
+                }
+            // fall through
+            case SyntaxKind.NumericLiteral:
+            case SyntaxKind.StringLiteral:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
+                var parent = node.parent;
+                switch (parent.kind) {
+                    case SyntaxKind.VariableDeclaration:
+                    case SyntaxKind.Parameter:
+                    case SyntaxKind.Property:
+                    case SyntaxKind.EnumMember:
+                    case SyntaxKind.PropertyAssignment:
+                        return (<VariableDeclaration>parent).initializer === node;
+                    case SyntaxKind.ExpressionStatement:
+                    case SyntaxKind.IfStatement:
+                    case SyntaxKind.DoStatement:
+                    case SyntaxKind.WhileStatement:
+                    case SyntaxKind.ReturnStatement:
+                    case SyntaxKind.WithStatement:
+                    case SyntaxKind.SwitchStatement:
+                    case SyntaxKind.CaseClause:
+                    case SyntaxKind.ThrowStatement:
+                    case SyntaxKind.SwitchStatement:
+                        return (<ExpressionStatement>parent).expression === node;
+                    case SyntaxKind.ForStatement:
+                        return (<ForStatement>parent).initializer === node ||
+                            (<ForStatement>parent).condition === node ||
+                            (<ForStatement>parent).iterator === node;
+                    case SyntaxKind.ForInStatement:
+                        return (<ForInStatement>parent).variable === node ||
+                            (<ForInStatement>parent).expression === node;
+                    case SyntaxKind.TypeAssertion:
+                        return node === (<TypeAssertion>parent).operand;
+                    default:
+                        if (isExpression(parent)) {
+                            return true;
+                        }
+                }
+        }
+        return false;
+    }
+
     export function hasRestParameters(s: SignatureDeclaration): boolean {
         return s.parameters.length > 0 && (s.parameters[s.parameters.length - 1].flags & NodeFlags.Rest) !== 0;
     }
 
+    export function isLiteralKind(kind: SyntaxKind): boolean {
+        return SyntaxKind.FirstLiteralToken <= kind && kind <= SyntaxKind.LastLiteralToken;
+    }
+
+    export function isTextualLiteralKind(kind: SyntaxKind): boolean {
+        return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+    }
+
+    export function isTemplateLiteralKind(kind: SyntaxKind): boolean {
+        return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken;
+    }
+
     export function isInAmbientContext(node: Node): boolean {
         while (node) {
             if (node.flags & (NodeFlags.Ambient | NodeFlags.DeclarationFile)) return true;
@@ -538,6 +560,7 @@ module ts {
         return false;
     }
 
+
     export function isDeclaration(node: Node): boolean {
         switch (node.kind) {
             case SyntaxKind.TypeParameter:
@@ -955,6 +978,10 @@ module ts {
             return token = scanner.reScanSlashToken();
         }
 
+        function reScanTemplateToken(): SyntaxKind {
+            return token = scanner.reScanTemplateToken();
+        }
+
         function lookAheadHelper<T>(callback: () => T, alwaysResetState: boolean): T {
             // Keep track of the state we'll need to rollback to if lookahead fails (or if the 
             // caller asked us to always reset our state).
@@ -1100,7 +1127,9 @@ module ts {
         }
 
         function isPropertyName(): boolean {
-            return token >= SyntaxKind.Identifier || token === SyntaxKind.StringLiteral || token === SyntaxKind.NumericLiteral;
+            return token >= SyntaxKind.Identifier ||
+                token === SyntaxKind.StringLiteral ||
+                token === SyntaxKind.NumericLiteral;
         }
 
         function parsePropertyName(): Identifier {
@@ -1136,7 +1165,7 @@ module ts {
                 case ParsingContext.SwitchClauses:
                     return token === SyntaxKind.CaseKeyword || token === SyntaxKind.DefaultKeyword;
                 case ParsingContext.TypeMembers:
-                    return isTypeMember();
+                    return isStartOfTypeMember();
                 case ParsingContext.ClassMembers:
                     return lookAhead(isClassMemberStart);
                 case ParsingContext.EnumMembers:
@@ -1148,14 +1177,14 @@ module ts {
                 case ParsingContext.TypeParameters:
                     return isIdentifier();
                 case ParsingContext.ArgumentExpressions:
-                    return token === SyntaxKind.CommaToken || isExpression();
+                    return token === SyntaxKind.CommaToken || isStartOfExpression();
                 case ParsingContext.ArrayLiteralMembers:
-                    return token === SyntaxKind.CommaToken || isExpression();
+                    return token === SyntaxKind.CommaToken || isStartOfExpression();
                 case ParsingContext.Parameters:
-                    return isParameter();
+                    return isStartOfParameter();
                 case ParsingContext.TypeArguments:
                 case ParsingContext.TupleElementTypes:
-                    return token === SyntaxKind.CommaToken || isType();
+                    return token === SyntaxKind.CommaToken || isStartOfType();
             }
 
             Debug.fail("Non-exhaustive case in 'isListElement'.");
@@ -1375,7 +1404,48 @@ module ts {
             return finishNode(node);
         }
 
-        function parseLiteralNode(internName?:boolean): LiteralExpression {
+        function parseTemplateExpression() {
+            var template = <TemplateExpression>createNode(SyntaxKind.TemplateExpression);
+
+            template.head = parseLiteralNode();
+            Debug.assert(template.head.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
+
+            var templateSpans = <NodeArray<TemplateSpan>>[];
+            templateSpans.pos = getNodePos();
+            
+            do {
+                templateSpans.push(parseTemplateSpan());
+            }
+            while (templateSpans[templateSpans.length - 1].literal.kind === SyntaxKind.TemplateMiddle)
+            
+            templateSpans.end = getNodeEnd();
+            template.templateSpans = templateSpans;
+
+            return finishNode(template);
+        }
+
+        function parseTemplateSpan(): TemplateSpan {
+            var span = <TemplateSpan>createNode(SyntaxKind.TemplateSpan);
+            span.expression = parseExpression(/*noIn*/ false);
+
+            var literal: LiteralExpression;
+
+            if (token === SyntaxKind.CloseBraceToken) {
+                reScanTemplateToken()
+                literal = parseLiteralNode();
+            }
+            else {
+                error(Diagnostics.Invalid_template_literal_expected);
+                literal = <LiteralExpression>createMissingNode();
+                literal.text = "";
+            }
+
+            span.literal = literal;
+
+            return finishNode(span);
+        }
+
+        function parseLiteralNode(internName?: boolean): LiteralExpression {
             var node = <LiteralExpression>createNode(token);
             var text = scanner.getTokenValue();
             node.text = internName ? internIdentifier(text) : text;
@@ -1387,7 +1457,7 @@ module ts {
             // Octal literals are not allowed in strict mode or ES5
             // Note that theoretically the following condition would hold true literals like 009,
             // which is not octal.But because of how the scanner separates the tokens, we would
-            // never get a token like this.Instead, we would get 00 and 9 as two separate tokens.
+            // never get a token like this. Instead, we would get 00 and 9 as two separate tokens.
             // We also do not need to check for negatives because any prefix operator would be part of a
             // parent unary expression.
             if (node.kind === SyntaxKind.NumericLiteral
@@ -1406,7 +1476,9 @@ module ts {
         }
 
         function parseStringLiteral(): LiteralExpression {
-            if (token === SyntaxKind.StringLiteral) return parseLiteralNode(/*internName:*/ true);
+            if (token === SyntaxKind.StringLiteral) {
+                return parseLiteralNode(/*internName:*/ true);
+            }
             error(Diagnostics.String_literal_expected);
             return <LiteralExpression>createMissingNode();
         }
@@ -1437,7 +1509,7 @@ module ts {
                 // user writes a constraint that is an expression and not an actual type, then parse
                 // it out as an expression (so we can recover well), but report that a type is needed
                 // instead.
-                if (isType() || !isExpression()) {
+                if (isStartOfType() || !isStartOfExpression()) {
                     node.constraint = parseType();
                 }
                 else {
@@ -1473,7 +1545,7 @@ module ts {
             return parseOptional(SyntaxKind.ColonToken) ? token === SyntaxKind.StringLiteral ? parseStringLiteral() : parseType() : undefined;
         }
 
-        function isParameter(): boolean {
+        function isStartOfParameter(): boolean {
             return token === SyntaxKind.DotDotDotToken || isIdentifier() || isModifier(token);
         }
 
@@ -1681,7 +1753,7 @@ module ts {
             return finishNode(node);
         }
 
-        function isTypeMember(): boolean {
+        function isStartOfTypeMember(): boolean {
             switch (token) {
                 case SyntaxKind.OpenParenToken:
                 case SyntaxKind.LessThanToken:
@@ -1788,7 +1860,7 @@ module ts {
             return <TypeNode>createMissingNode();
         }
 
-        function isType(): boolean {
+        function isStartOfType(): boolean {
             switch (token) {
                 case SyntaxKind.AnyKeyword:
                 case SyntaxKind.StringKeyword:
@@ -1806,7 +1878,7 @@ module ts {
                     // or something that starts a type. We don't want to consider things like '(1)' a type.
                     return lookAhead(() => {
                         nextToken();
-                        return token === SyntaxKind.CloseParenToken || isParameter() || isType();
+                        return token === SyntaxKind.CloseParenToken || isStartOfParameter() || isStartOfType();
                     });
                 default:
                     return isIdentifier();
@@ -1840,7 +1912,7 @@ module ts {
             return type;
         }
 
-        function isFunctionType(): boolean {
+        function isStartOfFunctionType(): boolean {
             return token === SyntaxKind.LessThanToken || token === SyntaxKind.OpenParenToken && lookAhead(() => {
                 nextToken();
                 if (token === SyntaxKind.CloseParenToken || token === SyntaxKind.DotDotDotToken) {
@@ -1873,7 +1945,7 @@ module ts {
         }
 
         function parseType(): TypeNode {
-            if (isFunctionType()) {
+            if (isStartOfFunctionType()) {
                 return parseFunctionType(SyntaxKind.CallSignature);
             }
             if (token === SyntaxKind.NewKeyword) {
@@ -1888,7 +1960,7 @@ module ts {
 
         // EXPRESSIONS
 
-        function isExpression(): boolean {
+        function isStartOfExpression(): boolean {
             switch (token) {
                 case SyntaxKind.ThisKeyword:
                 case SyntaxKind.SuperKeyword:
@@ -1897,6 +1969,8 @@ module ts {
                 case SyntaxKind.FalseKeyword:
                 case SyntaxKind.NumericLiteral:
                 case SyntaxKind.StringLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
+                case SyntaxKind.TemplateHead:
                 case SyntaxKind.OpenParenToken:
                 case SyntaxKind.OpenBracketToken:
                 case SyntaxKind.OpenBraceToken:
@@ -1921,9 +1995,9 @@ module ts {
             }
         }
 
-        function isExpressionStatement(): boolean {
+        function isStartOfExpressionStatement(): boolean {
             // As per the grammar, neither '{' nor 'function' can start an expression statement.
-            return token !== SyntaxKind.OpenBraceToken && token !== SyntaxKind.FunctionKeyword && isExpression();
+            return token !== SyntaxKind.OpenBraceToken && token !== SyntaxKind.FunctionKeyword && isStartOfExpression();
         }
 
         function parseExpression(noIn?: boolean): Expression {
@@ -1944,7 +2018,7 @@ module ts {
                 // it's more likely that a { would be a allowed (as an object literal).  While this
                 // is also allowed for parameters, the risk is that we consume the { as an object
                 // literal when it really will be for the block following the parameter.
-                if (scanner.hasPrecedingLineBreak() || (inParameter && token === SyntaxKind.OpenBraceToken) || !isExpression()) {
+                if (scanner.hasPrecedingLineBreak() || (inParameter && token === SyntaxKind.OpenBraceToken) || !isStartOfExpression()) {
                     // preceding line break, open brace in a parameter (likely a function body) or current token is not an expression - 
                     // do not try to parse initializer
                     return undefined;
@@ -1988,8 +2062,8 @@ module ts {
             }
 
             // Now see if we might be in cases '2' or '3'.
-            // If the expression was a LHS expression, and we  have an assignment operator, then 
-            // we're in '2' or '3'.  Consume the assignment and return.
+            // If the expression was a LHS expression, and we have an assignment operator, then 
+            // we're in '2' or '3'. Consume the assignment and return.
             if (isLeftHandSideExpression(expr) && isAssignmentOperator()) {
                 if (isInStrictMode && isEvalOrArgumentsIdentifier(expr)) {
                     // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an 
@@ -2012,6 +2086,7 @@ module ts {
                     case SyntaxKind.IndexedAccess:
                     case SyntaxKind.NewExpression:
                     case SyntaxKind.CallExpression:
+                    case SyntaxKind.TaggedTemplateExpression:
                     case SyntaxKind.ArrayLiteral:
                     case SyntaxKind.ParenExpression:
                     case SyntaxKind.ObjectLiteral:
@@ -2021,6 +2096,8 @@ module ts {
                     case SyntaxKind.RegularExpressionLiteral:
                     case SyntaxKind.NumericLiteral:
                     case SyntaxKind.StringLiteral:
+                    case SyntaxKind.NoSubstitutionTemplateLiteral:
+                    case SyntaxKind.TemplateExpression:
                     case SyntaxKind.FalseKeyword:
                     case SyntaxKind.NullKeyword:
                     case SyntaxKind.ThisKeyword:
@@ -2189,7 +2266,7 @@ module ts {
             if (token === SyntaxKind.OpenBraceToken) {
                 body = parseBody(/* ignoreMissingOpenBrace */ false);
             }
-            else if (isStatement(/* inErrorRecovery */ true) && !isExpressionStatement() && token !== SyntaxKind.FunctionKeyword) {
+            else if (isStatement(/* inErrorRecovery */ true) && !isStartOfExpressionStatement() && token !== SyntaxKind.FunctionKeyword) {
                 // Check if we got a plain statement (i.e. no expression-statements, no functions expressions/declarations)
                 //
                 // Here we try to recover from a potential error situation in the case where the 
@@ -2376,7 +2453,7 @@ module ts {
 
         function parseCallAndAccess(expr: Expression, inNewExpression: boolean): Expression {
             while (true) {
-                var dotStart = scanner.getTokenPos();
+                var dotOrBracketStart = scanner.getTokenPos();
                 if (parseOptional(SyntaxKind.DotToken)) {
                     var propertyAccess = <PropertyAccess>createNode(SyntaxKind.PropertyAccess, expr.pos);
                     // Technically a keyword is valid here as all keywords are identifier names.
@@ -2399,7 +2476,7 @@ module ts {
                     // In the first case though, ASI will not take effect because there is not a
                     // line terminator after the keyword.
                     if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord() && lookAhead(() => scanner.isReservedWord())) {
-                        grammarErrorAtPos(dotStart, scanner.getStartPos() - dotStart, Diagnostics.Identifier_expected);
+                        grammarErrorAtPos(dotOrBracketStart, scanner.getStartPos() - dotOrBracketStart, Diagnostics.Identifier_expected);
                         var id = <Identifier>createMissingNode();
                     }
                     else {
@@ -2412,7 +2489,6 @@ module ts {
                     continue;
                 }
 
-                var bracketStart = scanner.getTokenPos();
                 if (parseOptional(SyntaxKind.OpenBracketToken)) {
 
                     var indexedAccess = <IndexedAccess>createNode(SyntaxKind.IndexedAccess, expr.pos);
@@ -2422,7 +2498,7 @@ module ts {
                     // Check for that common pattern and report a better error message.
                     if (inNewExpression && parseOptional(SyntaxKind.CloseBracketToken)) {
                         indexedAccess.index = createMissingNode();
-                        grammarErrorAtPos(bracketStart, scanner.getStartPos() - bracketStart, Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);
+                        grammarErrorAtPos(dotOrBracketStart, scanner.getStartPos() - dotOrBracketStart, Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);
                     }
                     else {
                         indexedAccess.index = parseExpression();
@@ -2455,6 +2531,22 @@ module ts {
                     expr = finishNode(callExpr);
                     continue;
                 }
+
+                if (token === SyntaxKind.NoSubstitutionTemplateLiteral || token === SyntaxKind.TemplateHead) {
+                    var tagExpression = <TaggedTemplateExpression>createNode(SyntaxKind.TaggedTemplateExpression, expr.pos);
+                    tagExpression.tag = expr;
+                    tagExpression.template = token === SyntaxKind.NoSubstitutionTemplateLiteral
+                        ? parseLiteralNode()
+                        : parseTemplateExpression();
+                    expr = finishNode(tagExpression);
+
+                    if (languageVersion < ScriptTarget.ES6) {
+                        grammarErrorOnNode(expr, Diagnostics.Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher);
+                    }
+
+                    continue;
+                }
+
                 return expr;
             }
         }
@@ -2501,6 +2593,7 @@ module ts {
                     return parseTokenNode();
                 case SyntaxKind.NumericLiteral:
                 case SyntaxKind.StringLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
                     return parseLiteralNode();
                 case SyntaxKind.OpenParenToken:
                     return parseParenExpression();
@@ -2518,6 +2611,9 @@ module ts {
                         return parseLiteralNode();
                     }
                     break;
+                case SyntaxKind.TemplateHead:
+                    return parseTemplateExpression();
+                    
                 default:
                     if (isIdentifier()) {
                         return parseIdentifier();
@@ -3176,7 +3272,7 @@ module ts {
                 case SyntaxKind.TypeKeyword:
                     // When followed by an identifier, these do not start a statement but might
                     // instead be following declarations
-                    if (isDeclaration()) {
+                    if (isDeclarationStart()) {
                         return false;
                     }
                 case SyntaxKind.PublicKeyword:
@@ -3189,7 +3285,7 @@ module ts {
                         return false;
                     }
                 default:
-                    return isExpression();
+                    return isStartOfExpression();
             }
         }
 
@@ -3920,7 +4016,7 @@ module ts {
             return finishNode(node);
         }
 
-        function isDeclaration(): boolean {
+        function isDeclarationStart(): boolean {
             switch (token) {
                 case SyntaxKind.VarKeyword:
                 case SyntaxKind.LetKeyword:
@@ -3939,14 +4035,14 @@ module ts {
                     return lookAhead(() => nextToken() >= SyntaxKind.Identifier || token === SyntaxKind.StringLiteral);
                 case SyntaxKind.ExportKeyword:
                     // Check for export assignment or modifier on source element
-                    return lookAhead(() => nextToken() === SyntaxKind.EqualsToken || isDeclaration());
+                    return lookAhead(() => nextToken() === SyntaxKind.EqualsToken || isDeclarationStart());
                 case SyntaxKind.DeclareKeyword:
                 case SyntaxKind.PublicKeyword:
                 case SyntaxKind.PrivateKeyword:
                 case SyntaxKind.ProtectedKeyword:
                 case SyntaxKind.StaticKeyword:
                     // Check for modifier on source element
-                    return lookAhead(() => { nextToken(); return isDeclaration(); });
+                    return lookAhead(() => { nextToken(); return isDeclarationStart(); });
             }
         }
 
@@ -4010,7 +4106,7 @@ module ts {
         }
 
         function isSourceElement(inErrorRecovery: boolean): boolean {
-            return isDeclaration() || isStatement(inErrorRecovery);
+            return isDeclarationStart() || isStatement(inErrorRecovery);
         }
 
         function parseSourceElement() {
@@ -4022,7 +4118,7 @@ module ts {
         }
 
         function parseSourceElementOrModuleElement(modifierContext: ModifierContext): Statement {
-            if (isDeclaration()) {
+            if (isDeclarationStart()) {
                 return parseDeclaration(modifierContext);
             }
 
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 75b14801ae7..29593ddf92e 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -24,6 +24,7 @@ module ts {
         isReservedWord(): boolean;
         reScanGreaterToken(): SyntaxKind;
         reScanSlashToken(): SyntaxKind;
+        reScanTemplateToken(): SyntaxKind;
         scan(): SyntaxKind;
         setText(text: string): void;
         setTextPos(textPos: number): void;
@@ -466,7 +467,7 @@ module ts {
         var len: number;       // Length of text
         var startPos: number;  // Start position of whitespace before current token
         var tokenPos: number;  // Start position of text of current token
-        var token: number;
+        var token: SyntaxKind;
         var tokenValue: string;
         var precedingLineBreak: boolean;
 
@@ -519,10 +520,10 @@ module ts {
             return +(text.substring(start, pos));
         }
 
-        function scanHexDigits(count: number, exact?: boolean): number {
+        function scanHexDigits(count: number, mustMatchCount?: boolean): number {
             var digits = 0;
             var value = 0;
-            while (digits < count || !exact) {
+            while (digits < count || !mustMatchCount) {
                 var ch = text.charCodeAt(pos);
                 if (ch >= CharacterCodes._0 && ch <= CharacterCodes._9) {
                     value = value * 16 + ch - CharacterCodes._0;
@@ -563,60 +564,7 @@ module ts {
                 }
                 if (ch === CharacterCodes.backslash) {
                     result += text.substring(start, pos);
-                    pos++;
-                    if (pos >= len) {
-                        error(Diagnostics.Unexpected_end_of_text);
-                        break;
-                    }
-                    ch = text.charCodeAt(pos++);
-                    switch (ch) {
-                        case CharacterCodes._0:
-                            result += "\0";
-                            break;
-                        case CharacterCodes.b:
-                            result += "\b";
-                            break;
-                        case CharacterCodes.t:
-                            result += "\t";
-                            break;
-                        case CharacterCodes.n:
-                            result += "\n";
-                            break;
-                        case CharacterCodes.v:
-                            result += "\v";
-                            break;
-                        case CharacterCodes.f:
-                            result += "\f";
-                            break;
-                        case CharacterCodes.r:
-                            result += "\r";
-                            break;
-                        case CharacterCodes.singleQuote:
-                            result += "\'";
-                            break;
-                        case CharacterCodes.doubleQuote:
-                            result += "\"";
-                            break;
-                        case CharacterCodes.x:
-                        case CharacterCodes.u:
-                            var ch = scanHexDigits(ch === CharacterCodes.x ? 2 : 4, true);
-                            if (ch >= 0) {
-                                result += String.fromCharCode(ch);
-                            }
-                            else {
-                                error(Diagnostics.Hexadecimal_digit_expected);
-                            }
-                            break;
-                        case CharacterCodes.carriageReturn:
-                            if (pos < len && text.charCodeAt(pos) === CharacterCodes.lineFeed) pos++;
-                            break;
-                        case CharacterCodes.lineFeed:
-                        case CharacterCodes.lineSeparator:
-                        case CharacterCodes.paragraphSeparator:
-                            break;
-                        default:
-                            result += String.fromCharCode(ch);
-                    }
+                    result += scanEscapeSequence();
                     start = pos;
                     continue;
                 }
@@ -630,13 +578,136 @@ module ts {
             return result;
         }
 
+        /**
+         * Sets the current 'tokenValue' and returns a NoSubstitutionTemplateLiteral or
+         * a literal component of a TemplateExpression.
+         */
+        function scanTemplateAndSetTokenValue(): SyntaxKind {
+            var startedWithBacktick = text.charCodeAt(pos) === CharacterCodes.backtick;
+
+            pos++;
+            var start = pos;
+            var contents = ""
+            var resultingToken: SyntaxKind;
+
+            while (true) {
+                if (pos >= len) {
+                    contents += text.substring(start, pos);
+                    error(Diagnostics.Unexpected_end_of_text);
+                    resultingToken = startedWithBacktick ? SyntaxKind.NoSubstitutionTemplateLiteral : SyntaxKind.TemplateTail;
+                    break;
+                }
+
+                var currChar = text.charCodeAt(pos);
+
+                // '`'
+                if (currChar === CharacterCodes.backtick) {
+                    contents += text.substring(start, pos);
+                    pos++;
+                    resultingToken = startedWithBacktick ? SyntaxKind.NoSubstitutionTemplateLiteral : SyntaxKind.TemplateTail;
+                    break;
+                }
+
+                // '${'
+                if (currChar === CharacterCodes.$ && pos + 1 < len && text.charCodeAt(pos + 1) === CharacterCodes.openBrace) {
+                    contents += text.substring(start, pos);
+                    pos += 2;
+                    resultingToken = startedWithBacktick ? SyntaxKind.TemplateHead : SyntaxKind.TemplateMiddle;
+                    break;
+                }
+
+                // Escape character
+                if (currChar === CharacterCodes.backslash) {
+                    contents += text.substring(start, pos);
+                    contents += scanEscapeSequence();
+                    start = pos;
+                    continue;
+                }
+
+                // Speculated ECMAScript 6 Spec 11.8.6.1:
+                // <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for Template Values
+                // An explicit EscapeSequence is needed to include a <CR> or <CR><LF> sequence.
+                if (currChar === CharacterCodes.carriageReturn) {
+                    contents += text.substring(start, pos);
+
+                    if (pos + 1 < len && text.charCodeAt(pos + 1) === CharacterCodes.lineFeed) {
+                        pos++;
+                    }
+                    pos++;
+                    contents += "\n";
+                    start = pos;
+                    continue;
+                }
+
+                pos++;
+            }
+
+            Debug.assert(resultingToken !== undefined);
+
+            tokenValue = contents;
+            return resultingToken;
+        }
+
+        function scanEscapeSequence(): string {
+            pos++;
+            if (pos >= len) {
+                error(Diagnostics.Unexpected_end_of_text);
+                return "";
+            }
+            var ch = text.charCodeAt(pos++);
+            switch (ch) {
+                case CharacterCodes._0:
+                    return "\0";
+                case CharacterCodes.b:
+                    return "\b";
+                case CharacterCodes.t:
+                    return "\t";
+                case CharacterCodes.n:
+                    return "\n";
+                case CharacterCodes.v:
+                    return "\v";
+                case CharacterCodes.f:
+                    return "\f";
+                case CharacterCodes.r:
+                    return "\r";
+                case CharacterCodes.singleQuote:
+                    return "\'";
+                case CharacterCodes.doubleQuote:
+                    return "\"";
+                case CharacterCodes.x:
+                case CharacterCodes.u:
+                    var ch = scanHexDigits(ch === CharacterCodes.x ? 2 : 4, /*mustMatchCount*/ true);
+                    if (ch >= 0) {
+                        return String.fromCharCode(ch);
+                    }
+                    else {
+                        error(Diagnostics.Hexadecimal_digit_expected);
+                        return ""
+                    }
+
+                // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence),
+                // the line terminator is interpreted to be "the empty code unit sequence".
+                case CharacterCodes.carriageReturn:
+                    if (pos < len && text.charCodeAt(pos) === CharacterCodes.lineFeed) {
+                        pos++;
+                    }
+                    // fall through
+                case CharacterCodes.lineFeed:
+                case CharacterCodes.lineSeparator:
+                case CharacterCodes.paragraphSeparator:
+                    return ""
+                default:
+                    return String.fromCharCode(ch);
+            }
+        }
+
         // Current character is known to be a backslash. Check for Unicode escape of the form '\uXXXX'
         // and return code point value if valid Unicode escape is found. Otherwise return -1.
         function peekUnicodeEscape(): number {
             if (pos + 5 < len && text.charCodeAt(pos + 1) === CharacterCodes.u) {
                 var start = pos;
                 pos += 2;
-                var value = scanHexDigits(4, true);
+                var value = scanHexDigits(4, /*mustMatchCount*/ true);
                 pos = start;
                 return value;
             }
@@ -735,6 +806,8 @@ module ts {
                     case CharacterCodes.singleQuote:
                         tokenValue = scanString();
                         return token = SyntaxKind.StringLiteral;
+                    case CharacterCodes.backtick:
+                        return token = scanTemplateAndSetTokenValue()
                     case CharacterCodes.percent:
                         if (text.charCodeAt(pos + 1) === CharacterCodes.equals) {
                             return pos += 2, token = SyntaxKind.PercentEqualsToken;
@@ -852,7 +925,7 @@ module ts {
                     case CharacterCodes._0:
                         if (pos + 2 < len && (text.charCodeAt(pos + 1) === CharacterCodes.X || text.charCodeAt(pos + 1) === CharacterCodes.x)) {
                             pos += 2;
-                            var value = scanHexDigits(1, false);
+                            var value = scanHexDigits(1, /*mustMatchCount*/ false);
                             if (value < 0) {
                                 error(Diagnostics.Hexadecimal_digit_expected);
                                 value = 0;
@@ -1038,6 +1111,15 @@ module ts {
             return token;
         }
 
+        /**
+         * Unconditionally back up and scan a template expression portion.
+         */
+        function reScanTemplateToken(): SyntaxKind {
+            Debug.assert(token === SyntaxKind.CloseBraceToken, "'reScanTemplateToken' should only be called on a '}'");
+            pos = tokenPos;
+            return token = scanTemplateAndSetTokenValue();
+        }
+
         function tryScan<T>(callback: () => T): T {
             var savePos = pos;
             var saveStartPos = startPos;
@@ -1086,10 +1168,11 @@ module ts {
             isReservedWord: () => token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord,
             reScanGreaterToken: reScanGreaterToken,
             reScanSlashToken: reScanSlashToken,
+            reScanTemplateToken: reScanTemplateToken,
             scan: scan,
             setText: setText,
             setTextPos: setTextPos,
-            tryScan: tryScan
+            tryScan: tryScan,
         };
     }
 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 6a51691f1ab..ead84957731 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -20,6 +20,11 @@ module ts {
         NumericLiteral,
         StringLiteral,
         RegularExpressionLiteral,
+        NoSubstitutionTemplateLiteral,
+        // Pseudo-literals
+        TemplateHead,
+        TemplateMiddle,
+        TemplateTail,
         // Punctuation
         OpenBraceToken,
         CloseBraceToken,
@@ -165,6 +170,7 @@ module ts {
         IndexedAccess,
         CallExpression,
         NewExpression,
+        TaggedTemplateExpression,
         TypeAssertion,
         ParenExpression,
         FunctionExpression,
@@ -173,6 +179,8 @@ module ts {
         PostfixOperator,
         BinaryExpression,
         ConditionalExpression,
+        TemplateExpression,
+        TemplateSpan,
         OmittedExpression,
         // Element
         Block,
@@ -234,7 +242,11 @@ module ts {
         FirstToken = EndOfFileToken,
         LastToken = TypeKeyword,
         FirstTriviaToken = SingleLineCommentTrivia,
-        LastTriviaToken = WhitespaceTrivia
+        LastTriviaToken = WhitespaceTrivia,
+        FirstLiteralToken = NumericLiteral,
+        LastLiteralToken = NoSubstitutionTemplateLiteral,
+        FirstTemplateToken = NoSubstitutionTemplateLiteral,
+        LastTemplateToken = TemplateTail
     }
 
     export enum NodeFlags {
@@ -379,13 +391,25 @@ module ts {
         body: Block | Expression;  // Required, whereas the member inherited from FunctionDeclaration is optional
     }
 
-    // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral
-    // this means quotes have been removed and escapes have been converted to actual characters. For a NumericLiteral, the
-    // stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
+    // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
+    // or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.
+    // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
     export interface LiteralExpression extends Expression {
         text: string;
     }
 
+    export interface TemplateExpression extends Expression {
+        head: LiteralExpression;
+        templateSpans: NodeArray<TemplateSpan>;
+    }
+
+    // Each of these corresponds to a substitution expression and a template literal, in that order.
+    // The template literal must have kind TemplateMiddleLiteral or TemplateTailLiteral.
+    export interface TemplateSpan extends Node {
+        expression: Expression;
+        literal: LiteralExpression;
+    }
+
     export interface ParenExpression extends Expression {
         expression: Expression;
     }
@@ -416,6 +440,11 @@ module ts {
 
     export interface NewExpression extends CallExpression { }
 
+    export interface TaggedTemplateExpression extends Expression {
+        tag: Expression;
+        template: LiteralExpression | TemplateExpression;
+    }
+
     export interface TypeAssertion extends Expression {
         type: TypeNode;
         operand: Expression;
@@ -776,7 +805,6 @@ module ts {
         ExportValue            = 0x00200000,  // Exported value marker
         ExportType             = 0x00400000,  // Exported type marker
         ExportNamespace        = 0x00800000,  // Exported namespace marker
-
         Import                 = 0x01000000,  // Import
         Instantiated           = 0x02000000,  // Instantiated symbol
         Merged                 = 0x04000000,  // Merged symbol (created during program binding)
@@ -1218,6 +1246,7 @@ module ts {
         asterisk = 0x2A,              // *
         at = 0x40,                    // @
         backslash = 0x5C,             // \
+        backtick = 0x60,              // `
         bar = 0x7C,                   // |
         caret = 0x5E,                 // ^
         closeBrace = 0x7D,            // }
diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
index 5dfc75b29a5..6f7a7c335a0 100644
--- a/src/harness/typeWriter.ts
+++ b/src/harness/typeWriter.ts
@@ -92,7 +92,7 @@ class TypeWriterWalker {
 
     private getTypeOfNode(node: ts.Node): ts.Type {
         var type = this.checker.getTypeOfNode(node);
-        ts.Debug.assert(type, "type doesn't exist");
+        ts.Debug.assert(type !== undefined, "type doesn't exist");
         return type;
     }
 }
diff --git a/src/services/formatting/indentationTrackingWalker.ts b/src/services/formatting/indentationTrackingWalker.ts
index 2863b2e4fcc..60330872a86 100644
--- a/src/services/formatting/indentationTrackingWalker.ts
+++ b/src/services/formatting/indentationTrackingWalker.ts
@@ -104,8 +104,8 @@ module TypeScript.Services.Formatting {
                     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));
+                    for (var i = 0, n = element.childCount(); i < n; i++) {
+                        this.walk(element.childAt(i));
                     }
                 }
                 else {
@@ -126,8 +126,8 @@ module TypeScript.Services.Formatting {
                 this._parent = this._indentationNodeContextPool.getNode(currentParent, node, this._position, indentation.indentationAmount, indentation.indentationAmountDelta);
 
                 // Visit node
-                for (var i = 0, n = childCount(node); i < n; i++) {
-                    this.walk(childAt(node, i));
+                for (var i = 0, n = node.childCount(); i < n; i++) {
+                    this.walk(node.childAt(i));
                 }
 
                 // Reset state
diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts
index 12d36dd4d2b..e31c6687428 100644
--- a/src/services/formatting/smartIndenter.ts
+++ b/src/services/formatting/smartIndenter.ts
@@ -175,7 +175,7 @@ module ts.formatting {
         function childStartsOnTheSameLineWithElseInIfStatement(parent: Node, child: Node, childStartLine: number, sourceFile: SourceFile): boolean {
             if (parent.kind === SyntaxKind.IfStatement && (<IfStatement>parent).elseStatement === child) {
                 var elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile);
-                Debug.assert(elseKeyword);
+                Debug.assert(elseKeyword !== undefined);
 
                 var elseKeywordStartLine =  getStartLineAndCharacterForNode(elseKeyword, sourceFile).line;
                 return elseKeywordStartLine === childStartLine;
diff --git a/src/services/services.ts b/src/services/services.ts
index 4d4a4f94ea5..d208eb87e96 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1639,7 +1639,7 @@ module ts {
             }
 
             if (syntaxTree !== null) {
-                Debug.assert(sourceFile);
+                Debug.assert(sourceFile !== undefined);
                 // All done, ensure state is up to date
                 this.currentFileVersion = version;
                 this.currentFilename = filename;
@@ -1847,9 +1847,9 @@ module ts {
             ): SourceFile {
 
             var bucket = getBucketForCompilationSettings(compilationSettings, /*createIfMissing*/ false);
-            Debug.assert(bucket);
+            Debug.assert(bucket !== undefined);
             var entry = lookUp(bucket, filename);
-            Debug.assert(entry);
+            Debug.assert(entry !== undefined);
 
             if (entry.sourceFile.isOpen === isOpen && entry.sourceFile.version === version) {
                 return entry.sourceFile;
@@ -1861,7 +1861,7 @@ module ts {
 
         function releaseDocument(filename: string, compilationSettings: CompilerOptions): void {
             var bucket = getBucketForCompilationSettings(compilationSettings, false);
-            Debug.assert(bucket);
+            Debug.assert(bucket !== undefined);
 
             var entry = lookUp(bucket, filename);
             entry.refCount--;
@@ -2471,31 +2471,54 @@ module ts {
             }
 
             function isCompletionListBlocker(previousToken: Node): boolean {
-                return isInStringOrRegularExpressionLiteral(previousToken) ||
+                return isInStringOrRegularExpressionOrTemplateLiteral(previousToken) ||
                     isIdentifierDefinitionLocation(previousToken) ||
                     isRightOfIllegalDot(previousToken);
             }
 
-            function isInStringOrRegularExpressionLiteral(previousToken: Node): boolean {
-                if (previousToken.kind === SyntaxKind.StringLiteral) {
+            function isInStringOrRegularExpressionOrTemplateLiteral(previousToken: Node): boolean {
+                if (previousToken.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(previousToken.kind)) {
                     // The position has to be either: 1. entirely within the token text, or 
                     // 2. at the end position, and the string literal is not terminated
+                    
                     var start = previousToken.getStart();
                     var end = previousToken.getEnd();
+
                     if (start < position && position < end) {
                         return true;
                     }
                     else if (position === end) {
                         var width = end - start;
                         var text = previousToken.getSourceFile().text;
-                        return width <= 1 ||
-                            text.charCodeAt(start) !== text.charCodeAt(end - 1) ||
-                            text.charCodeAt(end - 2) === CharacterCodes.backslash;
+
+                        // If the token is a single character, or its second-to-last charcter indicates an escape code,
+                        // then we can immediately say that we are in the middle of an unclosed string.
+                        if (width <= 1 || text.charCodeAt(end - 2) === CharacterCodes.backslash) {
+                            return true;
+                        }
+
+                        // Now check if the last character is a closing character for the token.
+                        switch (previousToken.kind) {
+                            case SyntaxKind.StringLiteral:
+                            case SyntaxKind.NoSubstitutionTemplateLiteral:
+                                return text.charCodeAt(start) !== text.charCodeAt(end - 1);
+
+                            case SyntaxKind.TemplateHead:
+                            case SyntaxKind.TemplateMiddle:
+                                return text.charCodeAt(end - 1) !== CharacterCodes.openBrace
+                                    || text.charCodeAt(end - 2) !== CharacterCodes.$;
+
+                            case SyntaxKind.TemplateTail:
+                                return text.charCodeAt(end - 1) !== CharacterCodes.backtick;
+                        }
+
+                        return false;
                     }
                 }
                 else if (previousToken.kind === SyntaxKind.RegularExpressionLiteral) {
                     return previousToken.getStart() < position && position < previousToken.getEnd();
                 }
+
                 return false;
             }
 
@@ -2647,7 +2670,7 @@ module ts {
             var symbol = lookUp(activeCompletionSession.symbols, entryName);
             if (symbol) {
                 var type = session.typeChecker.getTypeOfSymbol(symbol);
-                Debug.assert(type, "Could not find type for symbol");
+                Debug.assert(type !== undefined, "Could not find type for symbol");
                 var completionEntry = createCompletionEntry(symbol, session.typeChecker);
                 // TODO(drosen): Right now we just permit *all* semantic meanings when calling 'getSymbolKind'
                 //               which is permissible given that it is backwards compatible; but really we should consider
@@ -2748,7 +2771,7 @@ module ts {
                         }
                         if (rootSymbolFlags & SymbolFlags.GetAccessor) return ScriptElementKind.memberVariableElement;
                         if (rootSymbolFlags & SymbolFlags.SetAccessor) return ScriptElementKind.memberVariableElement;
-                        Debug.assert(rootSymbolFlags & SymbolFlags.Method);
+                        Debug.assert((rootSymbolFlags & SymbolFlags.Method) !== undefined);
                     }) || ScriptElementKind.memberFunctionElement;
                 }
                 return ScriptElementKind.memberVariableElement;
@@ -4927,6 +4950,10 @@ module ts {
                     // TODO: we should get another classification type for these literals.
                     return ClassificationTypeNames.stringLiteral;
                 }
+                else if (isTemplateLiteralKind(tokenKind)) {
+                    // TODO (drosen): we should *also* get another classification type for these literals.
+                    return ClassificationTypeNames.stringLiteral;
+                }
                 else if (tokenKind === SyntaxKind.Identifier) {
                     switch (token.parent.kind) {
                         case SyntaxKind.ClassDeclaration:
@@ -5163,7 +5190,7 @@ module ts {
                             descriptor = descriptors[i];
                         }
                     }
-                    Debug.assert(descriptor);
+                    Debug.assert(descriptor !== undefined);
 
                     // We don't want to match something like 'TODOBY', so we make sure a non 
                     // letter/digit follows the match.
diff --git a/src/services/signatureHelp.ts b/src/services/signatureHelp.ts
index a93cf2c276e..f0b4ddc5ef7 100644
--- a/src/services/signatureHelp.ts
+++ b/src/services/signatureHelp.ts
@@ -219,7 +219,7 @@ module ts.SignatureHelp {
                 // Find the list that starts right *after* the < or ( token.
                 // If the user has just opened a list, consider this item 0.
                 var list = getChildListThatStartsWithOpenerToken(parent, node, sourceFile);
-                Debug.assert(list);
+                Debug.assert(list !== undefined);
                 return {
                     list: list,
                     listItemIndex: 0
diff --git a/src/services/syntax/incrementalParser.ts b/src/services/syntax/incrementalParser.ts
index 6c6d81c0fef..29bdfefc23c 100644
--- a/src/services/syntax/incrementalParser.ts
+++ b/src/services/syntax/incrementalParser.ts
@@ -66,7 +66,7 @@ module TypeScript.IncrementalParser {
 
         // Start the cursor pointing at the first element in the source unit (if it exists).
         if (oldSourceUnit.moduleElements.length > 0) {
-            _oldSourceUnitCursor.pushElement(childAt(oldSourceUnit.moduleElements, 0), /*indexInParent:*/ 0);
+            _oldSourceUnitCursor.pushElement(oldSourceUnit.moduleElements.childAt(0), /*indexInParent:*/ 0);
         }
 
         // In general supporting multiple individual edits is just not that important.  So we 
@@ -719,8 +719,8 @@ module TypeScript.IncrementalParser {
             // Either the node has some existent child, then move to it.  if it doesn't, then it's
             // an empty node.  Conceptually the first child of an empty node is really just the 
             // next sibling of the empty node.
-            for (var i = 0, n = childCount(nodeOrToken); i < n; i++) {
-                var child = childAt(nodeOrToken, i);
+            for (var i = 0, n = nodeOrToken.childCount(); i < n; i++) {
+                var child = nodeOrToken.childAt(i);
                 if (child && !isShared(child)) {
                     // Great, we found a real child.  Push that.
                     pushElement(child, /*indexInParent:*/ i);
@@ -746,8 +746,8 @@ module TypeScript.IncrementalParser {
                 var parent = currentPiece.element.parent;
 
                 // We start searching at the index one past our own index in the parent.
-                for (var i = currentPiece.indexInParent + 1, n = childCount(parent); i < n; i++) {
-                    var sibling = childAt(parent, i);
+                for (var i = currentPiece.indexInParent + 1, n = parent.childCount(); i < n; i++) {
+                    var sibling = parent.childAt(i);
 
                     if (sibling && !isShared(sibling)) {
                         // We found a good sibling that we can move to.  Just reuse our existing piece
@@ -782,7 +782,7 @@ module TypeScript.IncrementalParser {
                 // we make sure to filter that out before pushing any children.
                 // Debug.assert(childCount(element) > 0);
 
-                pushElement(childAt(element, 0), /*indexInParent:*/ 0);
+                pushElement(element.childAt(0), /*indexInParent:*/ 0);
             }
         }
 
diff --git a/src/services/syntax/parser.ts b/src/services/syntax/parser.ts
index 74387549d9c..b67d56e636e 100644
--- a/src/services/syntax/parser.ts
+++ b/src/services/syntax/parser.ts
@@ -594,8 +594,8 @@ module TypeScript.Parser {
             }
             else if (isSeparatedList(parent)) {
                 var list2 = <ISyntaxNodeOrToken[]>parent;
-                for (var i = 0, n = childCount(list2); i < n; i++) {
-                    if (childAt(list2, i) === oldToken) {
+                for (var i = 0, n = list2.childCount(); i < n; i++) {
+                    if (list2.childAt(i) === oldToken) {
                         if (i % 2 === 0) {
                             list2[i / 2] = newToken;
                         }
diff --git a/src/services/syntax/prettyPrinter.ts b/src/services/syntax/prettyPrinter.ts
index 647590f5fcc..2c0441b28f5 100644
--- a/src/services/syntax/prettyPrinter.ts
+++ b/src/services/syntax/prettyPrinter.ts
@@ -52,7 +52,7 @@ module TypeScript.PrettyPrinter {
                 return 0;
             }
 
-            if (childCount(element1.statements) === 0) {
+            if (element1.statements.childCount() === 0) {
                 return 1;
             }
 
@@ -131,12 +131,12 @@ module TypeScript.PrettyPrinter {
         }
 
         private appendSpaceList(list: ISyntaxNodeOrToken[]): void {
-            for (var i = 0, n = childCount(list); i < n; i++) {
-                if (isNode(childAt(list, i))) {
-                    this.appendNode(<ISyntaxNode>childAt(list, i));
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                if (isNode(list.childAt(i))) {
+                    this.appendNode(<ISyntaxNode>list.childAt(i));
                 }
                 else {
-                    this.appendToken(<ISyntaxToken>childAt(list, i));
+                    this.appendToken(<ISyntaxToken>list.childAt(i));
                 }
 
                 this.ensureSpace();
@@ -144,31 +144,31 @@ module TypeScript.PrettyPrinter {
         }
 
         private appendSeparatorSpaceList(list: ISyntaxNodeOrToken[]): void {
-            for (var i = 0, n = childCount(list); i < n; i++) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
                 if (i % 2 === 0) {
                     if (i > 0) {
                         this.ensureSpace();
                     }
 
-                    visitNodeOrToken(this, childAt(list, i));
+                    visitNodeOrToken(this, list.childAt(i));
                 }
                 else {
-                    this.appendToken(<ISyntaxToken>childAt(list, i));
+                    this.appendToken(<ISyntaxToken>list.childAt(i));
                 }
             }
         }
 
         private appendSeparatorNewLineList(list: ISyntaxNodeOrToken[]): void {
-            for (var i = 0, n = childCount(list); i < n; i++) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
                 if (i % 2 === 0) {
                     if (i > 0) {
                         this.ensureNewLine();
                     }
 
-                    visitNodeOrToken(this, childAt(list, i));
+                    visitNodeOrToken(this, list.childAt(i));
                 }
                 else {
-                    this.appendToken(<ISyntaxToken>childAt(list, i));
+                    this.appendToken(<ISyntaxToken>list.childAt(i));
                 }
             }
         }
@@ -277,8 +277,8 @@ module TypeScript.PrettyPrinter {
                 this.ensureSpace();
             }
 
-            for (var i = 0, n = childCount(node.typeMembers); i < n; i++) {
-                visitNodeOrToken(this, childAt(node.typeMembers, i));
+            for (var i = 0, n = node.typeMembers.childCount(); i < n; i++) {
+                visitNodeOrToken(this, node.typeMembers.childAt(i));
 
                 if (appendNewLines) {
                     this.ensureNewLine();
@@ -774,11 +774,11 @@ module TypeScript.PrettyPrinter {
         }
 
         private appendSwitchClauseStatements(node: ISwitchClauseSyntax): void {
-            if (childCount(node.statements) === 1 && childAt(node.statements, 0).kind() === SyntaxKind.Block) {
+            if (node.statements.childCount() === 1 && node.statements.childAt(0).kind() === SyntaxKind.Block) {
                 this.ensureSpace();
-                visitNodeOrToken(this, childAt(node.statements, 0));
+                visitNodeOrToken(this, node.statements.childAt(0));
             }
-            else if (childCount(node.statements) > 0) {
+            else if (node.statements.childCount() > 0) {
                 this.ensureNewLine();
 
                 this.indentation++;
@@ -910,12 +910,12 @@ module TypeScript.PrettyPrinter {
         public visitObjectLiteralExpression(node: ObjectLiteralExpressionSyntax): void {
             this.appendToken(node.openBraceToken);
 
-            if (childCount(node.propertyAssignments) === 1) {
+            if (node.propertyAssignments.childCount() === 1) {
                 this.ensureSpace();
-                visitNodeOrToken(this, <ISyntaxNodeOrToken>childAt(node.propertyAssignments, 0));
+                visitNodeOrToken(this, <ISyntaxNodeOrToken>node.propertyAssignments.childAt(0));
                 this.ensureSpace();
             }
-            else if (childCount(node.propertyAssignments) > 0) {
+            else if (node.propertyAssignments.childCount() > 0) {
                 this.indentation++;
                 this.ensureNewLine();
                 this.appendSeparatorNewLineList(node.propertyAssignments);
diff --git a/src/services/syntax/scanner.ts b/src/services/syntax/scanner.ts
index 62959e458ff..26ede31047d 100644
--- a/src/services/syntax/scanner.ts
+++ b/src/services/syntax/scanner.ts
@@ -255,6 +255,10 @@ module TypeScript.Scanner {
             this._packedData = fixedWidthTokenPackData(fullStart, this.kind());
         }
 
+        public childCount() { return 0 }
+        public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
+        public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
+
         public isIncrementallyUnusable(): boolean { return false; }
         public isKeywordConvertedToIdentifier(): boolean { return false; }
         public hasSkippedToken(): boolean { return false; }
@@ -290,6 +294,10 @@ module TypeScript.Scanner {
                 largeTokenUnpackTriviaInfo(this._packedFullStartAndInfo));
         }
 
+        public childCount() { return 0 }
+        public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
+        public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
+
         private syntaxTreeText(text: ISimpleText) {
             var result = text || syntaxTree(this).text;
             Debug.assert(result);
diff --git a/src/services/syntax/syntax.ts b/src/services/syntax/syntax.ts
index 87974c850f7..96301d0c19c 100644
--- a/src/services/syntax/syntax.ts
+++ b/src/services/syntax/syntax.ts
@@ -4,8 +4,8 @@ module TypeScript.Syntax {
     export var _nextSyntaxID: number = 1;
 
     export function childIndex(parent: ISyntaxElement, child: ISyntaxElement) {
-        for (var i = 0, n = childCount(parent); i < n; i++) {
-            var current = childAt(parent, i);
+        for (var i = 0, n = parent.childCount(); i < n; i++) {
+            var current = parent.childAt(i);
             if (current === child) {
                 return i;
             }
@@ -15,8 +15,8 @@ module TypeScript.Syntax {
     }
 
     export function nodeHasSkippedOrMissingTokens(node: ISyntaxNode): boolean {
-        for (var i = 0; i < childCount(node); i++) {
-            var child = childAt(node, i);
+        for (var i = 0; i < node.childCount(); i++) {
+            var child = node.childAt(i);
             if (isToken(child)) {
                 var token = <ISyntaxToken>child;
                 // If a token is skipped, return true. Or if it is a missing token. The only empty token that is not missing is EOF
diff --git a/src/services/syntax/syntaxElement.ts b/src/services/syntax/syntaxElement.ts
index 53d16e7ef67..283307281d0 100644
--- a/src/services/syntax/syntaxElement.ts
+++ b/src/services/syntax/syntaxElement.ts
@@ -11,36 +11,6 @@ module TypeScript {
         return (kind === SyntaxKind.List || kind === SyntaxKind.SeparatedList) && (<ISyntaxNodeOrToken[]>element).length === 0;
     }
 
-    export function childCount(element: ISyntaxElement): number {
-        var kind = element.kind();
-        if (kind === SyntaxKind.List) {
-            return (<ISyntaxNodeOrToken[]>element).length;
-        }
-        else if (kind === SyntaxKind.SeparatedList) {
-            return (<ISyntaxNodeOrToken[]>element).length + (<ISyntaxNodeOrToken[]>element).separators.length;
-        }
-        else if (kind >= SyntaxKind.FirstToken && kind <= SyntaxKind.LastToken) {
-            return 0;
-        }
-        else {
-            return nodeMetadata[kind].length;
-        }
-    }
-
-    export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {
-        var kind = element.kind();
-        if (kind === SyntaxKind.List) {
-            return (<ISyntaxNodeOrToken[]>element)[index];
-        }
-        else if (kind === SyntaxKind.SeparatedList) {
-            return (index % 2 === 0) ? (<ISyntaxNodeOrToken[]>element)[index / 2] : (<ISyntaxNodeOrToken[]>element).separators[(index - 1) / 2];
-        }
-        else {
-            // Debug.assert(isNode(element));
-            return (<any>element)[nodeMetadata[element.kind()][index]];
-        }
-    }
-
     export function syntaxTree(element: ISyntaxElement): SyntaxTree {
         if (element) {
             Debug.assert(!isShared(element));
@@ -179,8 +149,8 @@ module TypeScript {
         }
 
         // Consider: we could use a binary search here to find the child more quickly.
-        for (var i = 0, n = childCount(element); i < n; i++) {
-            var child = childAt(element, i);
+        for (var i = 0, n = element.childCount(); i < n; i++) {
+            var child = element.childAt(i);
 
             if (child) {
                 var childFullWidth = fullWidth(child);
@@ -278,8 +248,8 @@ module TypeScript {
                 elements.push((<ISyntaxToken>element).fullText(text));
             }
             else {
-                for (var i = 0, n = childCount(element); i < n; i++) {
-                    collectTextElements(childAt(element, i), elements, text);
+                for (var i = 0, n = element.childCount(); i < n; i++) {
+                    collectTextElements(element.childAt(i), elements, text);
                 }
             }
         }
@@ -314,37 +284,10 @@ module TypeScript {
                 return fullWidth(element) > 0 || element.kind() === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : undefined;
             }
 
-            if (kind === SyntaxKind.List) {
-                var array = <ISyntaxNodeOrToken[]>element;
-                for (var i = 0, n = array.length; i < n; i++) {
-                    var token = firstToken(array[i]);
-                    if (token) {
-                        return token;
-                    }
-                }
-            }
-            else if (kind === SyntaxKind.SeparatedList) {
-                var array = <ISyntaxNodeOrToken[]>element;
-                var separators = array.separators;
-                for (var i = 0, n = array.length + separators.length; i < n; i++) {
-                    var token = firstToken(i % 2 === 0 ? array[i / 2] : separators[(i - 1) / 2]);
-                    if (token) {
-                        return token;
-                    }
-                }
-            }
-            else {
-                var metadata = nodeMetadata[kind];
-                for (var i = 0, n = metadata.length; i < n; i++) {
-                    var child = (<any>element)[metadata[i]];
-                    var token = firstToken(child);
-                    if (token) {
-                        return token;
-                    }
-                }
-
-                if (element.kind() === SyntaxKind.SourceUnit) {
-                    return (<SourceUnitSyntax>element).endOfFileToken;
+            for (var i = 0, n = element.childCount(); i < n; i++) {
+                var token = firstToken(element.childAt(i));
+                if (token) {
+                    return token;
                 }
             }
         }
@@ -361,8 +304,8 @@ module TypeScript {
             return (<SourceUnitSyntax>element).endOfFileToken;
         }
 
-        for (var i = childCount(element) - 1; i >= 0; i--) {
-            var child = childAt(element, i);
+        for (var i = element.childCount() - 1; i >= 0; i--) {
+            var child = element.childAt(i);
             if (child) {
                 var token = lastToken(child);
                 if (token) {
@@ -426,7 +369,7 @@ module TypeScript {
     }
 
     function computeData(element: ISyntaxElement): number {
-        var slotCount = childCount(element);
+        var slotCount = element.childCount();
 
         var fullWidth = 0;
 
@@ -434,7 +377,7 @@ module TypeScript {
         var isIncrementallyUnusable = slotCount === 0;
 
         for (var i = 0, n = slotCount; i < n; i++) {
-            var child = childAt(element, i);
+            var child = element.childAt(i);
 
             if (child) {
                 fullWidth += TypeScript.fullWidth(child);
@@ -485,6 +428,8 @@ module TypeScript {
     export interface ISyntaxElement {
         kind(): SyntaxKind;
         parent?: ISyntaxElement;
+        childCount(): number;
+        childAt(index: number): ISyntaxElement;
     }
 
     export interface ISyntaxNode extends ISyntaxNodeOrToken {
diff --git a/src/services/syntax/syntaxGenerator.ts b/src/services/syntax/syntaxGenerator.ts
index 667b2563839..9bf7256c42f 100644
--- a/src/services/syntax/syntaxGenerator.ts
+++ b/src/services/syntax/syntaxGenerator.ts
@@ -1,8 +1,9 @@
-///<reference path='..\core\references.ts' />
-///<reference path='..\core\environment.ts' />
+///<reference path='..\..\compiler\sys.ts' />
+///<reference path='..\..\services\core\arrayUtilities.ts' />
+///<reference path='..\..\services\core\stringUtilities.ts' />
 ///<reference path='syntaxFacts.ts' />
 ///<reference path='syntaxKind.ts' />
-///<reference path='..\..\..\tests\fidelity\es5compat.ts' />
+// ///<reference path='..\..\..\tests\fidelity\es5compat.ts' />
 
 // Adds argument checking to the generated nodes.  Argument checking appears to slow things down
 // parsing about 7%.  If we want to get that perf back, we can always remove this.
@@ -32,7 +33,7 @@ interface IMemberDefinition {
     excludeFromAST?: boolean;
 }
 
-var interfaces: TypeScript.IIndexable<any> = {
+var interfaces: any = {
     IMemberDeclarationSyntax: 'IClassElementSyntax',
     IStatementSyntax: 'IModuleElementSyntax',
     INameSyntax: 'ITypeSyntax',
@@ -1560,22 +1561,34 @@ function generateBrands(definition: ITypeDefinition, accessibility: boolean): st
     return properties;
 }
 
+function generateAcceptMethod(definition: ITypeDefinition): string {
+    var result = "";
+
+    if (!hasKind) {
+        result += "\r\n";
+        result += "        public accept(visitor: ISyntaxVisitor): SyntaxKind {\r\n";
+        result += "            return visitor.visit" + getNameWithoutSuffix(definition) + "(this);\r\n";
+        result += "        }\r\n";
+    }
+
+    return result;
+}
+
 function generateKindMethod(definition: ITypeDefinition): string {
     var result = "";
 
-    //if (!hasKind) {
-    //    result += "\r\n";
-    //    result += "        public get kind(): SyntaxKind {\r\n";
-    //    result += "            return SyntaxKind." + getNameWithoutSuffix(definition) + ";\r\n";
-    //    result += "        }\r\n";
-    //}
+    if (!hasKind) {
+        result += "\r\n";
+        result += "        public kind(): SyntaxKind {\r\n";
+        result += "            return SyntaxKind." + getNameWithoutSuffix(definition) + ";\r\n";
+        result += "        }\r\n";
+    }
 
     return result;
 }
 
 function generateSlotMethods(definition: ITypeDefinition): string {
     var result = "";
-    return result;
 
     result += "\r\n";
     result += "        public childCount(): number {\r\n";
@@ -1973,6 +1986,11 @@ function generateNode(definition: ITypeDefinition, abstract: boolean): string {
     }
 
     result += "        }\r\n";
+
+    result += generateKindMethod(definition);
+    result += generateSlotMethods(definition);
+    result += generateAcceptMethod(definition);
+
     result += "    }";
     return result;
 }
@@ -2020,6 +2038,7 @@ function generateSyntaxInterfaces(): string {
 
     result += "\r\n\r\n";
 
+    /*
     result += "    export var nodeMetadata: string[][] = [";
     for (var i = 0; i <= TypeScript.SyntaxKind.LastNode; i++) {
         if (i < TypeScript.SyntaxKind.FirstNode) {
@@ -2039,6 +2058,7 @@ function generateSyntaxInterfaces(): string {
         result += metadata;
     }
     result += "];\r\n\r\n";
+    */
 
     result += "    export module Syntax {\r\n"
 
@@ -2111,7 +2131,7 @@ function generateNodes(abstract: boolean): string {
 
         result += generateNode(definition, abstract);
     }
-
+    /*
     result += "\r\n\r\n    ";
 
     for (var i = 0; i < definitions.length; i++) {
@@ -2128,9 +2148,9 @@ function generateNodes(abstract: boolean): string {
         result += "(<any>" + definition.name + ").prototype.__kind = SyntaxKind." + getNameWithoutSuffix(definition)
     }
 
-    result += ";\r\n";
+    result += ";\r\n";*/
 
-    result += "}";
+    result += "\r\n}";
     return result;
 }
 
@@ -2285,16 +2305,28 @@ function generateWalker(): string {
 "            this.visitToken(token);\r\n" +
 "        }\r\n" +
 "\r\n" +
+"        private visitOptionalNode(node: ISyntaxNode): void {\r\n" +
+"            if (node === undefined) {\r\n" +
+"                return;\r\n" +
+"            }\r\n" +
+"\r\n" +
+"            node.accept(this);\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" +
-"               visitNodeOrToken(this, list[i]);\r\n" +
+"                list[i].accept(this);\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" +
-"                visitNodeOrToken(this, item);\r\n" + 
+"            for (var i = 0, n = separatedListChildCount(list); i < n; i++) {\r\n" +
+"                if (i % 2 === 0) {\r\n" +
+"                    list[i >> 1].accept(this);\r\n" + 
+"                }\r\n" +
+"                else {\r\n" +
+"                    this.visitToken(list.separators[i >> 1]);\r\n" +
+"                }\r\n" +
 "            }\r\n" +
 "        }\r\n";
 
@@ -2322,10 +2354,28 @@ function generateWalker(): string {
                 result += "            this.visitSeparatedList(node." + child.name + ");\r\n";
             }
             else if (isNodeOrToken(child)) {
-                result += "            visitNodeOrToken(this, node." + child.name + ");\r\n";
+                if (child.isOptional) {
+                    result += "            visitNodeOrToken(this, node." + child.name + ");\r\n";
+                }
+                else {
+                    result += "            node." + child.name + ".accept(this);\r\n";
+                }
+            }
+            else if (child.type === "ISyntaxToken") {
+                if (child.isOptional) {
+                    result += "            this.visitOptionalToken(node." + child.name + ");\r\n";
+                }
+                else {
+                    result += "            this.visitToken(node." + child.name + ");\r\n";
+                }
             }
             else if (child.type !== "SyntaxKind") {
-                result += "            visitNodeOrToken(this, node." + child.name + ");\r\n";
+                if (child.isOptional) {
+                    result += "            this.visitOptionalNode(node." + child.name + ");\r\n";
+                }
+                else {
+                    result += "            node." + child.name + ".accept(this);\r\n";
+                }
             }
         }
 
@@ -2346,7 +2396,7 @@ function firstEnumName(e: any, value: number) {
 }
 
 function groupBy<T>(array: T[], func: (v: T) => string): any {
-    var result: TypeScript.IIndexable<T[]> = {};
+    var result: any = {};
 
     for (var i = 0, n = array.length; i < n; i++) {
         var v: any = array[i];
@@ -2485,6 +2535,8 @@ function generateVisitor(): string {
     result += "module TypeScript {\r\n";
     result += "    export function visitNodeOrToken(visitor: ISyntaxVisitor, element: ISyntaxNodeOrToken): any {\r\n";
     result += "        if (element === undefined) { return undefined; }\r\n";
+    result += "        return element.accept(visitor);\r\n";
+    /*
     result += "        if (isToken(element)) { return visitor.visitToken(<ISyntaxToken>element); }\r\n";
     result += "        switch (element.kind()) {\r\n";
 
@@ -2507,13 +2559,14 @@ function generateVisitor(): string {
 
     result += "        }\r\n\r\n";
     result += "        throw Errors.invalidOperation();\r\n";
+    */
     result += "    }\r\n\r\n";
 
     result += "    export interface ISyntaxVisitor {\r\n";
     result += "        visitToken(token: ISyntaxToken): any;\r\n";
 
-    for (i = 0; i < definitions.length; i++) {
-        definition = definitions[i];
+    for (var i = 0; i < definitions.length; i++) {
+        var definition = definitions[i];
         result += "        visit" + getNameWithoutSuffix(definition) + "(node: " + definition.name + "): any;\r\n";
     }
 
@@ -2669,8 +2722,8 @@ function generateIsTypeScriptSpecific(): string {
     result += "module TypeScript {\r\n";
 
     result += "    function isSeparatedListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\r\n"
-    result += "        for (var i = 0, n = childCount(list); i < n; i++) {\r\n";
-    result += "            if (isTypeScriptSpecific(childAt(list, i))) {\r\n";
+    result += "        for (var i = 0, n = list.childCount(); i < n; i++) {\r\n";
+    result += "            if (isTypeScriptSpecific(list.childAt(i))) {\r\n";
     result += "                return true;\r\n";
     result += "            }\r\n";
     result += "        }\r\n\r\n";
@@ -2823,7 +2876,6 @@ function generateIsTypeScriptSpecificMethod(definition: ITypeDefinition): string
 }
 
 var syntaxNodesConcrete = generateNodes(/*abstract:*/ false);
-var syntaxNodesAbstract = generateNodes(/*abstract:*/ true);
 var syntaxInterfaces = generateSyntaxInterfaces();
 var rewriter = generateRewriter();
 var walker = generateWalker();
@@ -2832,12 +2884,11 @@ var visitor = generateVisitor();
 var defaultVisitor = generateDefaultVisitor();
 var servicesUtilities = generateServicesUtilities();
 
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\syntax\\syntaxNodes.abstract.generated.ts", syntaxNodesAbstract, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\syntax\\syntaxNodes.interfaces.generated.ts", syntaxInterfaces, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\services\\syntaxRewriter.generated.ts", rewriter, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\syntax\\syntaxWalker.generated.ts", walker, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\syntax\\syntaxVisitor.generated.ts", visitor, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\syntax\\defaultSyntaxVisitor.generated.ts", defaultVisitor, false);
-TypeScript.Environment.writeFile(TypeScript.Environment.currentDirectory() + "\\src\\services\\syntaxUtilities.generated.ts", servicesUtilities, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.interfaces.generated.ts", syntaxInterfaces, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxRewriter.generated.ts", rewriter, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxWalker.generated.ts", walker, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxVisitor.generated.ts", visitor, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\defaultSyntaxVisitor.generated.ts", defaultVisitor, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxUtilities.generated.ts", servicesUtilities, false);
diff --git a/src/services/syntax/syntaxNode.ts b/src/services/syntax/syntaxNode.ts
index 464c59793aa..ea1cd17db5b 100644
--- a/src/services/syntax/syntaxNode.ts
+++ b/src/services/syntax/syntaxNode.ts
@@ -2,7 +2,7 @@
 
 module TypeScript {
     export class SyntaxNode implements ISyntaxNodeOrToken {
-        private __kind: SyntaxKind;
+        // private __kind: SyntaxKind;
         public data: number;
         public parent: ISyntaxElement;
 
@@ -13,7 +13,19 @@ module TypeScript {
         }
 
         public kind(): SyntaxKind {
-            return this.__kind;
+            throw Errors.abstract();
+        }
+
+        public childCount(): number {
+            throw Errors.abstract();
+        }
+
+        public childAt(index: number): ISyntaxElement {
+            throw Errors.abstract();
+        }
+
+        public accept(visitor: ISyntaxVisitor): any {
+            throw Errors.abstract();
         }
     }
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxNodeOrToken.ts b/src/services/syntax/syntaxNodeOrToken.ts
index 695268d843f..2c2a6f808bd 100644
--- a/src/services/syntax/syntaxNodeOrToken.ts
+++ b/src/services/syntax/syntaxNodeOrToken.ts
@@ -2,5 +2,6 @@
 
 module TypeScript {
     export interface ISyntaxNodeOrToken extends ISyntaxElement {
+        accept(visitor: ISyntaxVisitor): any;
     }
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxNodes.abstract.generated.ts b/src/services/syntax/syntaxNodes.abstract.generated.ts
deleted file mode 100644
index 158ff7bf1c3..00000000000
--- a/src/services/syntax/syntaxNodes.abstract.generated.ts
+++ /dev/null
@@ -1,1225 +0,0 @@
-///<reference path='references.ts' />
-
-module TypeScript.Syntax.Abstract {
-    // Inject this module as the factory for producing syntax nodes in the parser.
-    Parser.syntaxFactory = Abstract;
-    export var isConcrete: boolean = false;
-
-    export class SourceUnitSyntax extends SyntaxNode {
-        public syntaxTree: SyntaxTree = undefined;
-        public moduleElements: IModuleElementSyntax[];
-        public endOfFileToken: ISyntaxToken;
-        constructor(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken) {
-            super(data);
-            this.parent = undefined,
-            this.moduleElements = moduleElements,
-            this.endOfFileToken = endOfFileToken,
-            !isShared(moduleElements) && (moduleElements.parent = this),
-            endOfFileToken.parent = this;
-        }
-    }
-    export class QualifiedNameSyntax extends SyntaxNode implements INameSyntax {
-        public left: INameSyntax;
-        public dotToken: ISyntaxToken;
-        public right: ISyntaxToken;
-        public _nameBrand: any; public _typeBrand: any;
-        constructor(data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken) {
-            super(data);
-            this.left = left,
-            this.right = right,
-            left.parent = this,
-            right.parent = this;
-        }
-    }
-    export class ObjectTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public openBraceToken: ISyntaxToken;
-        public typeMembers: ITypeMemberSyntax[];
-        public closeBraceToken: ISyntaxToken;
-        public _typeBrand: any;
-        constructor(data: number, openBraceToken: ISyntaxToken, typeMembers: ITypeMemberSyntax[], closeBraceToken: ISyntaxToken) {
-            super(data);
-            this.typeMembers = typeMembers,
-            !isShared(typeMembers) && (typeMembers.parent = this);
-        }
-    }
-    export class FunctionTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public typeParameterList: TypeParameterListSyntax;
-        public parameterList: ParameterListSyntax;
-        public equalsGreaterThanToken: ISyntaxToken;
-        public type: ITypeSyntax;
-        public _typeBrand: any;
-        constructor(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) {
-            super(data);
-            this.typeParameterList = typeParameterList,
-            this.parameterList = parameterList,
-            this.type = type,
-            typeParameterList && (typeParameterList.parent = this),
-            parameterList.parent = this,
-            type.parent = this;
-        }
-    }
-    export class ArrayTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public type: ITypeSyntax;
-        public openBracketToken: ISyntaxToken;
-        public closeBracketToken: ISyntaxToken;
-        public _typeBrand: any;
-        constructor(data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken) {
-            super(data);
-            this.type = type,
-            type.parent = this;
-        }
-    }
-    export class ConstructorTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public newKeyword: ISyntaxToken;
-        public typeParameterList: TypeParameterListSyntax;
-        public parameterList: ParameterListSyntax;
-        public equalsGreaterThanToken: ISyntaxToken;
-        public type: ITypeSyntax;
-        public _typeBrand: any;
-        constructor(data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) {
-            super(data);
-            this.typeParameterList = typeParameterList,
-            this.parameterList = parameterList,
-            this.type = type,
-            typeParameterList && (typeParameterList.parent = this),
-            parameterList.parent = this,
-            type.parent = this;
-        }
-    }
-    export class GenericTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public name: INameSyntax;
-        public typeArgumentList: TypeArgumentListSyntax;
-        public _typeBrand: any;
-        constructor(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax) {
-            super(data);
-            this.name = name,
-            this.typeArgumentList = typeArgumentList,
-            name.parent = this,
-            typeArgumentList.parent = this;
-        }
-    }
-    export class TypeQuerySyntax extends SyntaxNode implements ITypeSyntax {
-        public typeOfKeyword: ISyntaxToken;
-        public name: INameSyntax;
-        public _typeBrand: any;
-        constructor(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax) {
-            super(data);
-            this.name = name,
-            name.parent = this;
-        }
-    }
-    export class TupleTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public openBracketToken: ISyntaxToken;
-        public types: ITypeSyntax[];
-        public closeBracketToken: ISyntaxToken;
-        public _typeBrand: any;
-        constructor(data: number, openBracketToken: ISyntaxToken, types: ITypeSyntax[], closeBracketToken: ISyntaxToken) {
-            super(data);
-            this.types = types,
-            !isShared(types) && (types.parent = this);
-        }
-    }
-    export class UnionTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public left: ITypeSyntax;
-        public barToken: ISyntaxToken;
-        public right: ITypeSyntax;
-        public _typeBrand: any;
-        constructor(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) {
-            super(data);
-            this.left = left,
-            this.right = right,
-            left.parent = this,
-            right.parent = this;
-        }
-    }
-    export class ParenthesizedTypeSyntax extends SyntaxNode implements ITypeSyntax {
-        public openParenToken: ISyntaxToken;
-        public type: ITypeSyntax;
-        public closeParenToken: ISyntaxToken;
-        public _typeBrand: any;
-        constructor(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) {
-            super(data);
-            this.type = type,
-            type.parent = this;
-        }
-    }
-    export class InterfaceDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
-        public modifiers: ISyntaxToken[];
-        public interfaceKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public typeParameterList: TypeParameterListSyntax;
-        public heritageClauses: HeritageClauseSyntax[];
-        public body: ObjectTypeSyntax;
-        public _moduleElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax) {
-            super(data);
-            this.modifiers = modifiers,
-            this.identifier = identifier,
-            this.typeParameterList = typeParameterList,
-            this.heritageClauses = heritageClauses,
-            this.body = body,
-            !isShared(modifiers) && (modifiers.parent = this),
-            identifier.parent = this,
-            typeParameterList && (typeParameterList.parent = this),
-            !isShared(heritageClauses) && (heritageClauses.parent = this),
-            body.parent = this;
-        }
-    }
-    export class FunctionDeclarationSyntax extends SyntaxNode implements IStatementSyntax {
-        public modifiers: ISyntaxToken[];
-        public functionKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public block: BlockSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.identifier = identifier,
-            this.callSignature = callSignature,
-            this.block = block,
-            !isShared(modifiers) && (modifiers.parent = this),
-            identifier.parent = this,
-            callSignature.parent = this,
-            block && (block.parent = this);
-        }
-    }
-    export class ModuleDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
-        public modifiers: ISyntaxToken[];
-        public moduleKeyword: ISyntaxToken;
-        public name: INameSyntax;
-        public stringLiteral: ISyntaxToken;
-        public openBraceToken: ISyntaxToken;
-        public moduleElements: IModuleElementSyntax[];
-        public closeBraceToken: ISyntaxToken;
-        public _moduleElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.name = name,
-            this.stringLiteral = stringLiteral,
-            this.moduleElements = moduleElements,
-            !isShared(modifiers) && (modifiers.parent = this),
-            name && (name.parent = this),
-            stringLiteral && (stringLiteral.parent = this),
-            !isShared(moduleElements) && (moduleElements.parent = this);
-        }
-    }
-    export class ClassDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
-        public modifiers: ISyntaxToken[];
-        public classKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public typeParameterList: TypeParameterListSyntax;
-        public heritageClauses: HeritageClauseSyntax[];
-        public openBraceToken: ISyntaxToken;
-        public classElements: IClassElementSyntax[];
-        public closeBraceToken: ISyntaxToken;
-        public _moduleElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.identifier = identifier,
-            this.typeParameterList = typeParameterList,
-            this.heritageClauses = heritageClauses,
-            this.classElements = classElements,
-            !isShared(modifiers) && (modifiers.parent = this),
-            identifier.parent = this,
-            typeParameterList && (typeParameterList.parent = this),
-            !isShared(heritageClauses) && (heritageClauses.parent = this),
-            !isShared(classElements) && (classElements.parent = this);
-        }
-    }
-    export class EnumDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
-        public modifiers: ISyntaxToken[];
-        public enumKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public openBraceToken: ISyntaxToken;
-        public enumElements: EnumElementSyntax[];
-        public closeBraceToken: ISyntaxToken;
-        public _moduleElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: EnumElementSyntax[], closeBraceToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.identifier = identifier,
-            this.enumElements = enumElements,
-            !isShared(modifiers) && (modifiers.parent = this),
-            identifier.parent = this,
-            !isShared(enumElements) && (enumElements.parent = this);
-        }
-    }
-    export class ImportDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
-        public modifiers: ISyntaxToken[];
-        public importKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public equalsToken: ISyntaxToken;
-        public moduleReference: IModuleReferenceSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _moduleElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.identifier = identifier,
-            this.moduleReference = moduleReference,
-            !isShared(modifiers) && (modifiers.parent = this),
-            identifier.parent = this,
-            moduleReference.parent = this;
-        }
-    }
-    export class ExportAssignmentSyntax extends SyntaxNode implements IModuleElementSyntax {
-        public exportKeyword: ISyntaxToken;
-        public equalsToken: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public semicolonToken: ISyntaxToken;
-        public _moduleElementBrand: any;
-        constructor(data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.identifier = identifier,
-            identifier.parent = this;
-        }
-    }
-    export class MemberFunctionDeclarationSyntax extends SyntaxNode implements IMemberDeclarationSyntax {
-        public modifiers: ISyntaxToken[];
-        public propertyName: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public block: BlockSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _memberDeclarationBrand: any; public _classElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.propertyName = propertyName,
-            this.callSignature = callSignature,
-            this.block = block,
-            !isShared(modifiers) && (modifiers.parent = this),
-            propertyName.parent = this,
-            callSignature.parent = this,
-            block && (block.parent = this);
-        }
-    }
-    export class MemberVariableDeclarationSyntax extends SyntaxNode implements IMemberDeclarationSyntax {
-        public modifiers: ISyntaxToken[];
-        public variableDeclarator: VariableDeclaratorSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _memberDeclarationBrand: any; public _classElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], variableDeclarator: VariableDeclaratorSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.variableDeclarator = variableDeclarator,
-            !isShared(modifiers) && (modifiers.parent = this),
-            variableDeclarator.parent = this;
-        }
-    }
-    export class ConstructorDeclarationSyntax extends SyntaxNode implements IClassElementSyntax {
-        public modifiers: ISyntaxToken[];
-        public constructorKeyword: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public block: BlockSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _classElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], constructorKeyword: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.constructorKeyword = constructorKeyword,
-            this.callSignature = callSignature,
-            this.block = block,
-            !isShared(modifiers) && (modifiers.parent = this),
-            constructorKeyword.parent = this,
-            callSignature.parent = this,
-            block && (block.parent = this);
-        }
-    }
-    export class IndexMemberDeclarationSyntax extends SyntaxNode implements IClassElementSyntax {
-        public modifiers: ISyntaxToken[];
-        public indexSignature: IndexSignatureSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _classElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], indexSignature: IndexSignatureSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.indexSignature = indexSignature,
-            !isShared(modifiers) && (modifiers.parent = this),
-            indexSignature.parent = this;
-        }
-    }
-    export class GetAccessorSyntax extends SyntaxNode implements IMemberDeclarationSyntax, IPropertyAssignmentSyntax {
-        public modifiers: ISyntaxToken[];
-        public getKeyword: ISyntaxToken;
-        public propertyName: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public block: BlockSyntax;
-        public _memberDeclarationBrand: any; public _propertyAssignmentBrand: any; public _classElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
-            super(data);
-            this.modifiers = modifiers,
-            this.propertyName = propertyName,
-            this.callSignature = callSignature,
-            this.block = block,
-            !isShared(modifiers) && (modifiers.parent = this),
-            propertyName.parent = this,
-            callSignature.parent = this,
-            block.parent = this;
-        }
-    }
-    export class SetAccessorSyntax extends SyntaxNode implements IMemberDeclarationSyntax, IPropertyAssignmentSyntax {
-        public modifiers: ISyntaxToken[];
-        public setKeyword: ISyntaxToken;
-        public propertyName: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public block: BlockSyntax;
-        public _memberDeclarationBrand: any; public _propertyAssignmentBrand: any; public _classElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], setKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
-            super(data);
-            this.modifiers = modifiers,
-            this.propertyName = propertyName,
-            this.callSignature = callSignature,
-            this.block = block,
-            !isShared(modifiers) && (modifiers.parent = this),
-            propertyName.parent = this,
-            callSignature.parent = this,
-            block.parent = this;
-        }
-    }
-    export class PropertySignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
-        public propertyName: ISyntaxToken;
-        public questionToken: ISyntaxToken;
-        public typeAnnotation: TypeAnnotationSyntax;
-        public _typeMemberBrand: any;
-        constructor(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) {
-            super(data);
-            this.propertyName = propertyName,
-            this.questionToken = questionToken,
-            this.typeAnnotation = typeAnnotation,
-            propertyName.parent = this,
-            questionToken && (questionToken.parent = this),
-            typeAnnotation && (typeAnnotation.parent = this);
-        }
-    }
-    export class CallSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
-        public typeParameterList: TypeParameterListSyntax;
-        public parameterList: ParameterListSyntax;
-        public typeAnnotation: TypeAnnotationSyntax;
-        public _typeMemberBrand: any;
-        constructor(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax) {
-            super(data);
-            this.typeParameterList = typeParameterList,
-            this.parameterList = parameterList,
-            this.typeAnnotation = typeAnnotation,
-            typeParameterList && (typeParameterList.parent = this),
-            parameterList.parent = this,
-            typeAnnotation && (typeAnnotation.parent = this);
-        }
-    }
-    export class ConstructSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
-        public newKeyword: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public _typeMemberBrand: any;
-        constructor(data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax) {
-            super(data);
-            this.callSignature = callSignature,
-            callSignature.parent = this;
-        }
-    }
-    export class IndexSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
-        public openBracketToken: ISyntaxToken;
-        public parameters: ParameterSyntax[];
-        public closeBracketToken: ISyntaxToken;
-        public typeAnnotation: TypeAnnotationSyntax;
-        public _typeMemberBrand: any;
-        constructor(data: number, openBracketToken: ISyntaxToken, parameters: ParameterSyntax[], closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) {
-            super(data);
-            this.openBracketToken = openBracketToken,
-            this.parameters = parameters,
-            this.closeBracketToken = closeBracketToken,
-            this.typeAnnotation = typeAnnotation,
-            openBracketToken.parent = this,
-            !isShared(parameters) && (parameters.parent = this),
-            closeBracketToken.parent = this,
-            typeAnnotation && (typeAnnotation.parent = this);
-        }
-    }
-    export class MethodSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
-        public propertyName: ISyntaxToken;
-        public questionToken: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public _typeMemberBrand: any;
-        constructor(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax) {
-            super(data);
-            this.propertyName = propertyName,
-            this.questionToken = questionToken,
-            this.callSignature = callSignature,
-            propertyName.parent = this,
-            questionToken && (questionToken.parent = this),
-            callSignature.parent = this;
-        }
-    }
-    export class BlockSyntax extends SyntaxNode implements IStatementSyntax {
-        public openBraceToken: ISyntaxToken;
-        public statements: IStatementSyntax[];
-        public closeBraceToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken) {
-            super(data);
-            this.openBraceToken = openBraceToken,
-            this.statements = statements,
-            openBraceToken.parent = this,
-            !isShared(statements) && (statements.parent = this);
-        }
-    }
-    export class IfStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public ifKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public condition: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public statement: IStatementSyntax;
-        public elseClause: ElseClauseSyntax;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax) {
-            super(data);
-            this.condition = condition,
-            this.statement = statement,
-            this.elseClause = elseClause,
-            condition.parent = this,
-            statement.parent = this,
-            elseClause && (elseClause.parent = this);
-        }
-    }
-    export class VariableStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public modifiers: ISyntaxToken[];
-        public variableDeclaration: VariableDeclarationSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, modifiers: ISyntaxToken[], variableDeclaration: VariableDeclarationSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.modifiers = modifiers,
-            this.variableDeclaration = variableDeclaration,
-            !isShared(modifiers) && (modifiers.parent = this),
-            variableDeclaration.parent = this;
-        }
-    }
-    export class ExpressionStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public expression: IExpressionSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.expression = expression,
-            expression.parent = this;
-        }
-    }
-    export class ReturnStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public returnKeyword: ISyntaxToken;
-        public expression: IExpressionSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, returnKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.returnKeyword = returnKeyword,
-            this.expression = expression,
-            returnKeyword.parent = this,
-            expression && (expression.parent = this);
-        }
-    }
-    export class SwitchStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public switchKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public expression: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public openBraceToken: ISyntaxToken;
-        public switchClauses: ISwitchClauseSyntax[];
-        public closeBraceToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, switchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, openBraceToken: ISyntaxToken, switchClauses: ISwitchClauseSyntax[], closeBraceToken: ISyntaxToken) {
-            super(data);
-            this.expression = expression,
-            this.switchClauses = switchClauses,
-            expression.parent = this,
-            !isShared(switchClauses) && (switchClauses.parent = this);
-        }
-    }
-    export class BreakStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public breakKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, breakKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.breakKeyword = breakKeyword,
-            this.identifier = identifier,
-            breakKeyword.parent = this,
-            identifier && (identifier.parent = this);
-        }
-    }
-    export class ContinueStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public continueKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, continueKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.continueKeyword = continueKeyword,
-            this.identifier = identifier,
-            continueKeyword.parent = this,
-            identifier && (identifier.parent = this);
-        }
-    }
-    export class ForStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public forKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public variableDeclaration: VariableDeclarationSyntax;
-        public initializer: IExpressionSyntax;
-        public firstSemicolonToken: ISyntaxToken;
-        public condition: IExpressionSyntax;
-        public secondSemicolonToken: ISyntaxToken;
-        public incrementor: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public statement: IStatementSyntax;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax, firstSemicolonToken: ISyntaxToken, condition: IExpressionSyntax, secondSemicolonToken: ISyntaxToken, incrementor: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
-            super(data);
-            this.variableDeclaration = variableDeclaration,
-            this.initializer = initializer,
-            this.condition = condition,
-            this.incrementor = incrementor,
-            this.statement = statement,
-            variableDeclaration && (variableDeclaration.parent = this),
-            initializer && (initializer.parent = this),
-            condition && (condition.parent = this),
-            incrementor && (incrementor.parent = this),
-            statement.parent = this;
-        }
-    }
-    export class ForInStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public forKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public variableDeclaration: VariableDeclarationSyntax;
-        public left: IExpressionSyntax;
-        public inKeyword: ISyntaxToken;
-        public expression: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public statement: IStatementSyntax;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, left: IExpressionSyntax, inKeyword: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
-            super(data);
-            this.variableDeclaration = variableDeclaration,
-            this.left = left,
-            this.expression = expression,
-            this.statement = statement,
-            variableDeclaration && (variableDeclaration.parent = this),
-            left && (left.parent = this),
-            expression.parent = this,
-            statement.parent = this;
-        }
-    }
-    export class EmptyStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.semicolonToken = semicolonToken,
-            semicolonToken.parent = this;
-        }
-    }
-    export class ThrowStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public throwKeyword: ISyntaxToken;
-        public expression: IExpressionSyntax;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, throwKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.expression = expression,
-            expression.parent = this;
-        }
-    }
-    export class WhileStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public whileKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public condition: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public statement: IStatementSyntax;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
-            super(data);
-            this.condition = condition,
-            this.statement = statement,
-            condition.parent = this,
-            statement.parent = this;
-        }
-    }
-    export class TryStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public tryKeyword: ISyntaxToken;
-        public block: BlockSyntax;
-        public catchClause: CatchClauseSyntax;
-        public finallyClause: FinallyClauseSyntax;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, tryKeyword: ISyntaxToken, block: BlockSyntax, catchClause: CatchClauseSyntax, finallyClause: FinallyClauseSyntax) {
-            super(data);
-            this.block = block,
-            this.catchClause = catchClause,
-            this.finallyClause = finallyClause,
-            block.parent = this,
-            catchClause && (catchClause.parent = this),
-            finallyClause && (finallyClause.parent = this);
-        }
-    }
-    export class LabeledStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public identifier: ISyntaxToken;
-        public colonToken: ISyntaxToken;
-        public statement: IStatementSyntax;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, identifier: ISyntaxToken, colonToken: ISyntaxToken, statement: IStatementSyntax) {
-            super(data);
-            this.identifier = identifier,
-            this.statement = statement,
-            identifier.parent = this,
-            statement.parent = this;
-        }
-    }
-    export class DoStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public doKeyword: ISyntaxToken;
-        public statement: IStatementSyntax;
-        public whileKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public condition: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, doKeyword: ISyntaxToken, statement: IStatementSyntax, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.statement = statement,
-            this.condition = condition,
-            statement.parent = this,
-            condition.parent = this;
-        }
-    }
-    export class DebuggerStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public debuggerKeyword: ISyntaxToken;
-        public semicolonToken: ISyntaxToken;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, debuggerKeyword: ISyntaxToken, semicolonToken: ISyntaxToken) {
-            super(data);
-            this.debuggerKeyword = debuggerKeyword,
-            debuggerKeyword.parent = this;
-        }
-    }
-    export class WithStatementSyntax extends SyntaxNode implements IStatementSyntax {
-        public withKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public condition: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public statement: IStatementSyntax;
-        public _statementBrand: any; public _moduleElementBrand: any;
-        constructor(data: number, withKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
-            super(data);
-            this.condition = condition,
-            this.statement = statement,
-            condition.parent = this,
-            statement.parent = this;
-        }
-    }
-    export class PrefixUnaryExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
-        public operatorToken: ISyntaxToken;
-        public operand: IUnaryExpressionSyntax;
-        public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, operatorToken: ISyntaxToken, operand: IUnaryExpressionSyntax) {
-            super(data);
-            this.operatorToken = operatorToken,
-            this.operand = operand,
-            operatorToken.parent = this,
-            operand.parent = this;
-        }
-    }
-    export class DeleteExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
-        public deleteKeyword: ISyntaxToken;
-        public expression: IUnaryExpressionSyntax;
-        public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, deleteKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) {
-            super(data);
-            this.expression = expression,
-            expression.parent = this;
-        }
-    }
-    export class TypeOfExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
-        public typeOfKeyword: ISyntaxToken;
-        public expression: IUnaryExpressionSyntax;
-        public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, typeOfKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) {
-            super(data);
-            this.expression = expression,
-            expression.parent = this;
-        }
-    }
-    export class VoidExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
-        public voidKeyword: ISyntaxToken;
-        public expression: IUnaryExpressionSyntax;
-        public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, voidKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) {
-            super(data);
-            this.expression = expression,
-            expression.parent = this;
-        }
-    }
-    export class ConditionalExpressionSyntax extends SyntaxNode implements IExpressionSyntax {
-        public condition: IExpressionSyntax;
-        public questionToken: ISyntaxToken;
-        public whenTrue: IExpressionSyntax;
-        public colonToken: ISyntaxToken;
-        public whenFalse: IExpressionSyntax;
-        public _expressionBrand: any;
-        constructor(data: number, condition: IExpressionSyntax, questionToken: ISyntaxToken, whenTrue: IExpressionSyntax, colonToken: ISyntaxToken, whenFalse: IExpressionSyntax) {
-            super(data);
-            this.condition = condition,
-            this.whenTrue = whenTrue,
-            this.whenFalse = whenFalse,
-            condition.parent = this,
-            whenTrue.parent = this,
-            whenFalse.parent = this;
-        }
-    }
-    export class BinaryExpressionSyntax extends SyntaxNode implements IExpressionSyntax {
-        public left: IExpressionSyntax;
-        public operatorToken: ISyntaxToken;
-        public right: IExpressionSyntax;
-        public _expressionBrand: any;
-        constructor(data: number, left: IExpressionSyntax, operatorToken: ISyntaxToken, right: IExpressionSyntax) {
-            super(data);
-            this.left = left,
-            this.operatorToken = operatorToken,
-            this.right = right,
-            left.parent = this,
-            operatorToken.parent = this,
-            right.parent = this;
-        }
-    }
-    export class PostfixUnaryExpressionSyntax extends SyntaxNode implements IPostfixExpressionSyntax {
-        public operand: ILeftHandSideExpressionSyntax;
-        public operatorToken: ISyntaxToken;
-        public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken) {
-            super(data);
-            this.operand = operand,
-            this.operatorToken = operatorToken,
-            operand.parent = this,
-            operatorToken.parent = this;
-        }
-    }
-    export class MemberAccessExpressionSyntax extends SyntaxNode implements IMemberExpressionSyntax, ICallExpressionSyntax {
-        public expression: ILeftHandSideExpressionSyntax;
-        public dotToken: ISyntaxToken;
-        public name: ISyntaxToken;
-        public _memberExpressionBrand: any; public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken) {
-            super(data);
-            this.expression = expression,
-            this.name = name,
-            expression.parent = this,
-            name.parent = this;
-        }
-    }
-    export class InvocationExpressionSyntax extends SyntaxNode implements ICallExpressionSyntax {
-        public expression: ILeftHandSideExpressionSyntax;
-        public argumentList: ArgumentListSyntax;
-        public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax) {
-            super(data);
-            this.expression = expression,
-            this.argumentList = argumentList,
-            expression.parent = this,
-            argumentList.parent = this;
-        }
-    }
-    export class ArrayLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
-        public openBracketToken: ISyntaxToken;
-        public expressions: IExpressionSyntax[];
-        public closeBracketToken: ISyntaxToken;
-        public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, openBracketToken: ISyntaxToken, expressions: IExpressionSyntax[], closeBracketToken: ISyntaxToken) {
-            super(data);
-            this.expressions = expressions,
-            !isShared(expressions) && (expressions.parent = this);
-        }
-    }
-    export class ObjectLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
-        public openBraceToken: ISyntaxToken;
-        public propertyAssignments: IPropertyAssignmentSyntax[];
-        public closeBraceToken: ISyntaxToken;
-        public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, openBraceToken: ISyntaxToken, propertyAssignments: IPropertyAssignmentSyntax[], closeBraceToken: ISyntaxToken) {
-            super(data);
-            this.propertyAssignments = propertyAssignments,
-            !isShared(propertyAssignments) && (propertyAssignments.parent = this);
-        }
-    }
-    export class ObjectCreationExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
-        public newKeyword: ISyntaxToken;
-        public expression: IMemberExpressionSyntax;
-        public argumentList: ArgumentListSyntax;
-        public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax) {
-            super(data);
-            this.expression = expression,
-            this.argumentList = argumentList,
-            expression.parent = this,
-            argumentList && (argumentList.parent = this);
-        }
-    }
-    export class ParenthesizedExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
-        public openParenToken: ISyntaxToken;
-        public expression: IExpressionSyntax;
-        public closeParenToken: ISyntaxToken;
-        public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken) {
-            super(data);
-            this.expression = expression,
-            expression.parent = this;
-        }
-    }
-    export class ParenthesizedArrowFunctionExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
-        public callSignature: CallSignatureSyntax;
-        public equalsGreaterThanToken: ISyntaxToken;
-        public block: BlockSyntax;
-        public expression: IExpressionSyntax;
-        public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) {
-            super(data);
-            this.callSignature = callSignature,
-            this.block = block,
-            this.expression = expression,
-            callSignature.parent = this,
-            block && (block.parent = this),
-            expression && (expression.parent = this);
-        }
-    }
-    export class SimpleArrowFunctionExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
-        public parameter: ParameterSyntax;
-        public equalsGreaterThanToken: ISyntaxToken;
-        public block: BlockSyntax;
-        public expression: IExpressionSyntax;
-        public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, parameter: ParameterSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) {
-            super(data);
-            this.parameter = parameter,
-            this.block = block,
-            this.expression = expression,
-            parameter.parent = this,
-            block && (block.parent = this),
-            expression && (expression.parent = this);
-        }
-    }
-    export class CastExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
-        public lessThanToken: ISyntaxToken;
-        public type: ITypeSyntax;
-        public greaterThanToken: ISyntaxToken;
-        public expression: IUnaryExpressionSyntax;
-        public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax) {
-            super(data);
-            this.type = type,
-            this.expression = expression,
-            type.parent = this,
-            expression.parent = this;
-        }
-    }
-    export class ElementAccessExpressionSyntax extends SyntaxNode implements IMemberExpressionSyntax, ICallExpressionSyntax {
-        public expression: ILeftHandSideExpressionSyntax;
-        public openBracketToken: ISyntaxToken;
-        public argumentExpression: IExpressionSyntax;
-        public closeBracketToken: ISyntaxToken;
-        public _memberExpressionBrand: any; public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken) {
-            super(data);
-            this.expression = expression,
-            this.argumentExpression = argumentExpression,
-            expression.parent = this,
-            argumentExpression.parent = this;
-        }
-    }
-    export class FunctionExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
-        public functionKeyword: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public block: BlockSyntax;
-        public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
-        constructor(data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
-            super(data);
-            this.identifier = identifier,
-            this.callSignature = callSignature,
-            this.block = block,
-            identifier && (identifier.parent = this),
-            callSignature.parent = this,
-            block.parent = this;
-        }
-    }
-    export class OmittedExpressionSyntax extends SyntaxNode implements IExpressionSyntax {
-        public _expressionBrand: any;
-        constructor(data: number) {
-            super(data);
-        }
-    }
-    export class VariableDeclarationSyntax extends SyntaxNode {
-        public varKeyword: ISyntaxToken;
-        public variableDeclarators: VariableDeclaratorSyntax[];
-        constructor(data: number, varKeyword: ISyntaxToken, variableDeclarators: VariableDeclaratorSyntax[]) {
-            super(data);
-            this.varKeyword = varKeyword,
-            this.variableDeclarators = variableDeclarators,
-            varKeyword.parent = this,
-            !isShared(variableDeclarators) && (variableDeclarators.parent = this);
-        }
-    }
-    export class VariableDeclaratorSyntax extends SyntaxNode {
-        public propertyName: ISyntaxToken;
-        public typeAnnotation: TypeAnnotationSyntax;
-        public equalsValueClause: EqualsValueClauseSyntax;
-        constructor(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) {
-            super(data);
-            this.propertyName = propertyName,
-            this.typeAnnotation = typeAnnotation,
-            this.equalsValueClause = equalsValueClause,
-            propertyName.parent = this,
-            typeAnnotation && (typeAnnotation.parent = this),
-            equalsValueClause && (equalsValueClause.parent = this);
-        }
-    }
-    export class ArgumentListSyntax extends SyntaxNode {
-        public typeArgumentList: TypeArgumentListSyntax;
-        public openParenToken: ISyntaxToken;
-        public arguments: IExpressionSyntax[];
-        public closeParenToken: ISyntaxToken;
-        constructor(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: IExpressionSyntax[], closeParenToken: ISyntaxToken) {
-            super(data);
-            this.typeArgumentList = typeArgumentList,
-            this.arguments = _arguments,
-            typeArgumentList && (typeArgumentList.parent = this),
-            !isShared(_arguments) && (_arguments.parent = this);
-        }
-    }
-    export class ParameterListSyntax extends SyntaxNode {
-        public openParenToken: ISyntaxToken;
-        public parameters: ParameterSyntax[];
-        public closeParenToken: ISyntaxToken;
-        constructor(data: number, openParenToken: ISyntaxToken, parameters: ParameterSyntax[], closeParenToken: ISyntaxToken) {
-            super(data);
-            this.parameters = parameters,
-            !isShared(parameters) && (parameters.parent = this);
-        }
-    }
-    export class TypeArgumentListSyntax extends SyntaxNode {
-        public lessThanToken: ISyntaxToken;
-        public typeArguments: ITypeSyntax[];
-        public greaterThanToken: ISyntaxToken;
-        constructor(data: number, lessThanToken: ISyntaxToken, typeArguments: ITypeSyntax[], greaterThanToken: ISyntaxToken) {
-            super(data);
-            this.lessThanToken = lessThanToken,
-            this.typeArguments = typeArguments,
-            lessThanToken.parent = this,
-            !isShared(typeArguments) && (typeArguments.parent = this);
-        }
-    }
-    export class TypeParameterListSyntax extends SyntaxNode {
-        public lessThanToken: ISyntaxToken;
-        public typeParameters: TypeParameterSyntax[];
-        public greaterThanToken: ISyntaxToken;
-        constructor(data: number, lessThanToken: ISyntaxToken, typeParameters: TypeParameterSyntax[], greaterThanToken: ISyntaxToken) {
-            super(data);
-            this.lessThanToken = lessThanToken,
-            this.typeParameters = typeParameters,
-            lessThanToken.parent = this,
-            !isShared(typeParameters) && (typeParameters.parent = this);
-        }
-    }
-    export class HeritageClauseSyntax extends SyntaxNode {
-        public extendsOrImplementsKeyword: ISyntaxToken;
-        public typeNames: INameSyntax[];
-        constructor(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: INameSyntax[]) {
-            super(data);
-            this.extendsOrImplementsKeyword = extendsOrImplementsKeyword,
-            this.typeNames = typeNames,
-            extendsOrImplementsKeyword.parent = this,
-            !isShared(typeNames) && (typeNames.parent = this);
-        }
-    }
-    export class EqualsValueClauseSyntax extends SyntaxNode {
-        public equalsToken: ISyntaxToken;
-        public value: IExpressionSyntax;
-        constructor(data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax) {
-            super(data);
-            this.value = value,
-            value.parent = this;
-        }
-    }
-    export class CaseSwitchClauseSyntax extends SyntaxNode implements ISwitchClauseSyntax {
-        public caseKeyword: ISyntaxToken;
-        public expression: IExpressionSyntax;
-        public colonToken: ISyntaxToken;
-        public statements: IStatementSyntax[];
-        public _switchClauseBrand: any;
-        constructor(data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]) {
-            super(data);
-            this.expression = expression,
-            this.statements = statements,
-            expression.parent = this,
-            !isShared(statements) && (statements.parent = this);
-        }
-    }
-    export class DefaultSwitchClauseSyntax extends SyntaxNode implements ISwitchClauseSyntax {
-        public defaultKeyword: ISyntaxToken;
-        public colonToken: ISyntaxToken;
-        public statements: IStatementSyntax[];
-        public _switchClauseBrand: any;
-        constructor(data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]) {
-            super(data);
-            this.statements = statements,
-            !isShared(statements) && (statements.parent = this);
-        }
-    }
-    export class ElseClauseSyntax extends SyntaxNode {
-        public elseKeyword: ISyntaxToken;
-        public statement: IStatementSyntax;
-        constructor(data: number, elseKeyword: ISyntaxToken, statement: IStatementSyntax) {
-            super(data);
-            this.statement = statement,
-            statement.parent = this;
-        }
-    }
-    export class CatchClauseSyntax extends SyntaxNode {
-        public catchKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public identifier: ISyntaxToken;
-        public typeAnnotation: TypeAnnotationSyntax;
-        public closeParenToken: ISyntaxToken;
-        public block: BlockSyntax;
-        constructor(data: number, catchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, identifier: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, closeParenToken: ISyntaxToken, block: BlockSyntax) {
-            super(data);
-            this.identifier = identifier,
-            this.typeAnnotation = typeAnnotation,
-            this.block = block,
-            identifier.parent = this,
-            typeAnnotation && (typeAnnotation.parent = this),
-            block.parent = this;
-        }
-    }
-    export class FinallyClauseSyntax extends SyntaxNode {
-        public finallyKeyword: ISyntaxToken;
-        public block: BlockSyntax;
-        constructor(data: number, finallyKeyword: ISyntaxToken, block: BlockSyntax) {
-            super(data);
-            this.block = block,
-            block.parent = this;
-        }
-    }
-    export class TypeParameterSyntax extends SyntaxNode {
-        public identifier: ISyntaxToken;
-        public constraint: ConstraintSyntax;
-        constructor(data: number, identifier: ISyntaxToken, constraint: ConstraintSyntax) {
-            super(data);
-            this.identifier = identifier,
-            this.constraint = constraint,
-            identifier.parent = this,
-            constraint && (constraint.parent = this);
-        }
-    }
-    export class ConstraintSyntax extends SyntaxNode {
-        public extendsKeyword: ISyntaxToken;
-        public typeOrExpression: ISyntaxNodeOrToken;
-        constructor(data: number, extendsKeyword: ISyntaxToken, typeOrExpression: ISyntaxNodeOrToken) {
-            super(data);
-            this.typeOrExpression = typeOrExpression,
-            typeOrExpression.parent = this;
-        }
-    }
-    export class SimplePropertyAssignmentSyntax extends SyntaxNode implements IPropertyAssignmentSyntax {
-        public propertyName: ISyntaxToken;
-        public colonToken: ISyntaxToken;
-        public expression: IExpressionSyntax;
-        public _propertyAssignmentBrand: any;
-        constructor(data: number, propertyName: ISyntaxToken, colonToken: ISyntaxToken, expression: IExpressionSyntax) {
-            super(data);
-            this.propertyName = propertyName,
-            this.expression = expression,
-            propertyName.parent = this,
-            expression.parent = this;
-        }
-    }
-    export class FunctionPropertyAssignmentSyntax extends SyntaxNode implements IPropertyAssignmentSyntax {
-        public propertyName: ISyntaxToken;
-        public callSignature: CallSignatureSyntax;
-        public block: BlockSyntax;
-        public _propertyAssignmentBrand: any;
-        constructor(data: number, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
-            super(data);
-            this.propertyName = propertyName,
-            this.callSignature = callSignature,
-            this.block = block,
-            propertyName.parent = this,
-            callSignature.parent = this,
-            block.parent = this;
-        }
-    }
-    export class ParameterSyntax extends SyntaxNode {
-        public dotDotDotToken: ISyntaxToken;
-        public modifiers: ISyntaxToken[];
-        public identifier: ISyntaxToken;
-        public questionToken: ISyntaxToken;
-        public typeAnnotation: TypeAnnotationSyntax;
-        public equalsValueClause: EqualsValueClauseSyntax;
-        constructor(data: number, dotDotDotToken: ISyntaxToken, modifiers: ISyntaxToken[], identifier: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) {
-            super(data);
-            this.dotDotDotToken = dotDotDotToken,
-            this.modifiers = modifiers,
-            this.identifier = identifier,
-            this.questionToken = questionToken,
-            this.typeAnnotation = typeAnnotation,
-            this.equalsValueClause = equalsValueClause,
-            dotDotDotToken && (dotDotDotToken.parent = this),
-            !isShared(modifiers) && (modifiers.parent = this),
-            identifier.parent = this,
-            questionToken && (questionToken.parent = this),
-            typeAnnotation && (typeAnnotation.parent = this),
-            equalsValueClause && (equalsValueClause.parent = this);
-        }
-    }
-    export class EnumElementSyntax extends SyntaxNode {
-        public propertyName: ISyntaxToken;
-        public equalsValueClause: EqualsValueClauseSyntax;
-        constructor(data: number, propertyName: ISyntaxToken, equalsValueClause: EqualsValueClauseSyntax) {
-            super(data);
-            this.propertyName = propertyName,
-            this.equalsValueClause = equalsValueClause,
-            propertyName.parent = this,
-            equalsValueClause && (equalsValueClause.parent = this);
-        }
-    }
-    export class TypeAnnotationSyntax extends SyntaxNode {
-        public colonToken: ISyntaxToken;
-        public type: ITypeSyntax;
-        constructor(data: number, colonToken: ISyntaxToken, type: ITypeSyntax) {
-            super(data);
-            this.type = type,
-            type.parent = this;
-        }
-    }
-    export class ExternalModuleReferenceSyntax extends SyntaxNode implements IModuleReferenceSyntax {
-        public requireKeyword: ISyntaxToken;
-        public openParenToken: ISyntaxToken;
-        public stringLiteral: ISyntaxToken;
-        public closeParenToken: ISyntaxToken;
-        public _moduleReferenceBrand: any;
-        constructor(data: number, requireKeyword: ISyntaxToken, openParenToken: ISyntaxToken, stringLiteral: ISyntaxToken, closeParenToken: ISyntaxToken) {
-            super(data);
-            this.stringLiteral = stringLiteral,
-            stringLiteral.parent = this;
-        }
-    }
-    export class ModuleNameModuleReferenceSyntax extends SyntaxNode implements IModuleReferenceSyntax {
-        public moduleName: INameSyntax;
-        public _moduleReferenceBrand: any;
-        constructor(data: number, moduleName: INameSyntax) {
-            super(data);
-            this.moduleName = moduleName,
-            moduleName.parent = this;
-        }
-    }
-
-    (<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>UnionTypeSyntax).prototype.__kind = SyntaxKind.UnionType, (<any>ParenthesizedTypeSyntax).prototype.__kind = SyntaxKind.ParenthesizedType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>PrefixUnaryExpressionSyntax).prototype.__kind = SyntaxKind.PrefixUnaryExpression, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>BinaryExpressionSyntax).prototype.__kind = SyntaxKind.BinaryExpression, (<any>PostfixUnaryExpressionSyntax).prototype.__kind = SyntaxKind.PostfixUnaryExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kind = SyntaxKind.VariableDeclaration, (<any>VariableDeclaratorSyntax).prototype.__kind = SyntaxKind.VariableDeclarator, (<any>ArgumentListSyntax).prototype.__kind = SyntaxKind.ArgumentList, (<any>ParameterListSyntax).prototype.__kind = SyntaxKind.ParameterList, (<any>TypeArgumentListSyntax).prototype.__kind = SyntaxKind.TypeArgumentList, (<any>TypeParameterListSyntax).prototype.__kind = SyntaxKind.TypeParameterList, (<any>HeritageClauseSyntax).prototype.__kind = SyntaxKind.HeritageClause, (<any>EqualsValueClauseSyntax).prototype.__kind = SyntaxKind.EqualsValueClause, (<any>CaseSwitchClauseSyntax).prototype.__kind = SyntaxKind.CaseSwitchClause, (<any>DefaultSwitchClauseSyntax).prototype.__kind = SyntaxKind.DefaultSwitchClause, (<any>ElseClauseSyntax).prototype.__kind = SyntaxKind.ElseClause, (<any>CatchClauseSyntax).prototype.__kind = SyntaxKind.CatchClause, (<any>FinallyClauseSyntax).prototype.__kind = SyntaxKind.FinallyClause, (<any>TypeParameterSyntax).prototype.__kind = SyntaxKind.TypeParameter, (<any>ConstraintSyntax).prototype.__kind = SyntaxKind.Constraint, (<any>SimplePropertyAssignmentSyntax).prototype.__kind = SyntaxKind.SimplePropertyAssignment, (<any>FunctionPropertyAssignmentSyntax).prototype.__kind = SyntaxKind.FunctionPropertyAssignment, (<any>ParameterSyntax).prototype.__kind = SyntaxKind.Parameter, (<any>EnumElementSyntax).prototype.__kind = SyntaxKind.EnumElement, (<any>TypeAnnotationSyntax).prototype.__kind = SyntaxKind.TypeAnnotation, (<any>ExternalModuleReferenceSyntax).prototype.__kind = SyntaxKind.ExternalModuleReference, (<any>ModuleNameModuleReferenceSyntax).prototype.__kind = SyntaxKind.ModuleNameModuleReference;
-}
\ No newline at end of file
diff --git a/src/services/syntax/syntaxNodes.concrete.generated.ts b/src/services/syntax/syntaxNodes.concrete.generated.ts
index 0f119267315..ea5ded99908 100644
--- a/src/services/syntax/syntaxNodes.concrete.generated.ts
+++ b/src/services/syntax/syntaxNodes.concrete.generated.ts
@@ -17,6 +17,26 @@ module TypeScript.Syntax.Concrete {
             !isShared(moduleElements) && (moduleElements.parent = this),
             endOfFileToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.SourceUnit;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.moduleElements;
+                case 1: return this.endOfFileToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitSourceUnit(this);
+        }
     }
     export class QualifiedNameSyntax extends SyntaxNode implements INameSyntax {
         public left: INameSyntax;
@@ -32,6 +52,27 @@ module TypeScript.Syntax.Concrete {
             dotToken.parent = this,
             right.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.QualifiedName;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.left;
+                case 1: return this.dotToken;
+                case 2: return this.right;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitQualifiedName(this);
+        }
     }
     export class ObjectTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public openBraceToken: ISyntaxToken;
@@ -47,6 +88,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(typeMembers) && (typeMembers.parent = this),
             closeBraceToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ObjectType;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openBraceToken;
+                case 1: return this.typeMembers;
+                case 2: return this.closeBraceToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitObjectType(this);
+        }
     }
     export class FunctionTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public typeParameterList: TypeParameterListSyntax;
@@ -65,6 +127,28 @@ module TypeScript.Syntax.Concrete {
             equalsGreaterThanToken.parent = this,
             type.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.FunctionType;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.typeParameterList;
+                case 1: return this.parameterList;
+                case 2: return this.equalsGreaterThanToken;
+                case 3: return this.type;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitFunctionType(this);
+        }
     }
     export class ArrayTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public type: ITypeSyntax;
@@ -80,6 +164,27 @@ module TypeScript.Syntax.Concrete {
             openBracketToken.parent = this,
             closeBracketToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ArrayType;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.type;
+                case 1: return this.openBracketToken;
+                case 2: return this.closeBracketToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitArrayType(this);
+        }
     }
     export class ConstructorTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public newKeyword: ISyntaxToken;
@@ -101,6 +206,29 @@ module TypeScript.Syntax.Concrete {
             equalsGreaterThanToken.parent = this,
             type.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ConstructorType;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.newKeyword;
+                case 1: return this.typeParameterList;
+                case 2: return this.parameterList;
+                case 3: return this.equalsGreaterThanToken;
+                case 4: return this.type;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitConstructorType(this);
+        }
     }
     export class GenericTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public name: INameSyntax;
@@ -113,6 +241,26 @@ module TypeScript.Syntax.Concrete {
             name.parent = this,
             typeArgumentList.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.GenericType;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.name;
+                case 1: return this.typeArgumentList;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitGenericType(this);
+        }
     }
     export class TypeQuerySyntax extends SyntaxNode implements ITypeSyntax {
         public typeOfKeyword: ISyntaxToken;
@@ -125,6 +273,26 @@ module TypeScript.Syntax.Concrete {
             typeOfKeyword.parent = this,
             name.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TypeQuery;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.typeOfKeyword;
+                case 1: return this.name;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTypeQuery(this);
+        }
     }
     export class TupleTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public openBracketToken: ISyntaxToken;
@@ -140,6 +308,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(types) && (types.parent = this),
             closeBracketToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TupleType;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openBracketToken;
+                case 1: return this.types;
+                case 2: return this.closeBracketToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTupleType(this);
+        }
     }
     export class UnionTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public left: ITypeSyntax;
@@ -155,6 +344,27 @@ module TypeScript.Syntax.Concrete {
             barToken.parent = this,
             right.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.UnionType;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.left;
+                case 1: return this.barToken;
+                case 2: return this.right;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitUnionType(this);
+        }
     }
     export class ParenthesizedTypeSyntax extends SyntaxNode implements ITypeSyntax {
         public openParenToken: ISyntaxToken;
@@ -170,6 +380,27 @@ module TypeScript.Syntax.Concrete {
             type.parent = this,
             closeParenToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ParenthesizedType;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openParenToken;
+                case 1: return this.type;
+                case 2: return this.closeParenToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitParenthesizedType(this);
+        }
     }
     export class InterfaceDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
         public modifiers: ISyntaxToken[];
@@ -194,6 +425,30 @@ module TypeScript.Syntax.Concrete {
             !isShared(heritageClauses) && (heritageClauses.parent = this),
             body.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.InterfaceDeclaration;
+        }
+
+        public childCount(): number {
+            return 6;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.interfaceKeyword;
+                case 2: return this.identifier;
+                case 3: return this.typeParameterList;
+                case 4: return this.heritageClauses;
+                case 5: return this.body;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitInterfaceDeclaration(this);
+        }
     }
     export class FunctionDeclarationSyntax extends SyntaxNode implements IStatementSyntax {
         public modifiers: ISyntaxToken[];
@@ -218,6 +473,30 @@ module TypeScript.Syntax.Concrete {
             block && (block.parent = this),
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.FunctionDeclaration;
+        }
+
+        public childCount(): number {
+            return 6;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.functionKeyword;
+                case 2: return this.identifier;
+                case 3: return this.callSignature;
+                case 4: return this.block;
+                case 5: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitFunctionDeclaration(this);
+        }
     }
     export class ModuleDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
         public modifiers: ISyntaxToken[];
@@ -245,6 +524,31 @@ module TypeScript.Syntax.Concrete {
             !isShared(moduleElements) && (moduleElements.parent = this),
             closeBraceToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ModuleDeclaration;
+        }
+
+        public childCount(): number {
+            return 7;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.moduleKeyword;
+                case 2: return this.name;
+                case 3: return this.stringLiteral;
+                case 4: return this.openBraceToken;
+                case 5: return this.moduleElements;
+                case 6: return this.closeBraceToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitModuleDeclaration(this);
+        }
     }
     export class ClassDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
         public modifiers: ISyntaxToken[];
@@ -275,6 +579,32 @@ module TypeScript.Syntax.Concrete {
             !isShared(classElements) && (classElements.parent = this),
             closeBraceToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ClassDeclaration;
+        }
+
+        public childCount(): number {
+            return 8;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.classKeyword;
+                case 2: return this.identifier;
+                case 3: return this.typeParameterList;
+                case 4: return this.heritageClauses;
+                case 5: return this.openBraceToken;
+                case 6: return this.classElements;
+                case 7: return this.closeBraceToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitClassDeclaration(this);
+        }
     }
     export class EnumDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
         public modifiers: ISyntaxToken[];
@@ -299,6 +629,30 @@ module TypeScript.Syntax.Concrete {
             !isShared(enumElements) && (enumElements.parent = this),
             closeBraceToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.EnumDeclaration;
+        }
+
+        public childCount(): number {
+            return 6;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.enumKeyword;
+                case 2: return this.identifier;
+                case 3: return this.openBraceToken;
+                case 4: return this.enumElements;
+                case 5: return this.closeBraceToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitEnumDeclaration(this);
+        }
     }
     export class ImportDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
         public modifiers: ISyntaxToken[];
@@ -323,6 +677,30 @@ module TypeScript.Syntax.Concrete {
             moduleReference.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ImportDeclaration;
+        }
+
+        public childCount(): number {
+            return 6;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.importKeyword;
+                case 2: return this.identifier;
+                case 3: return this.equalsToken;
+                case 4: return this.moduleReference;
+                case 5: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitImportDeclaration(this);
+        }
     }
     export class ExportAssignmentSyntax extends SyntaxNode implements IModuleElementSyntax {
         public exportKeyword: ISyntaxToken;
@@ -341,6 +719,28 @@ module TypeScript.Syntax.Concrete {
             identifier.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ExportAssignment;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.exportKeyword;
+                case 1: return this.equalsToken;
+                case 2: return this.identifier;
+                case 3: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitExportAssignment(this);
+        }
     }
     export class MemberFunctionDeclarationSyntax extends SyntaxNode implements IMemberDeclarationSyntax {
         public modifiers: ISyntaxToken[];
@@ -362,6 +762,29 @@ module TypeScript.Syntax.Concrete {
             block && (block.parent = this),
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.MemberFunctionDeclaration;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.propertyName;
+                case 2: return this.callSignature;
+                case 3: return this.block;
+                case 4: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitMemberFunctionDeclaration(this);
+        }
     }
     export class MemberVariableDeclarationSyntax extends SyntaxNode implements IMemberDeclarationSyntax {
         public modifiers: ISyntaxToken[];
@@ -377,6 +800,27 @@ module TypeScript.Syntax.Concrete {
             variableDeclarator.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.MemberVariableDeclaration;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.variableDeclarator;
+                case 2: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitMemberVariableDeclaration(this);
+        }
     }
     export class ConstructorDeclarationSyntax extends SyntaxNode implements IClassElementSyntax {
         public modifiers: ISyntaxToken[];
@@ -398,6 +842,29 @@ module TypeScript.Syntax.Concrete {
             block && (block.parent = this),
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ConstructorDeclaration;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.constructorKeyword;
+                case 2: return this.callSignature;
+                case 3: return this.block;
+                case 4: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitConstructorDeclaration(this);
+        }
     }
     export class IndexMemberDeclarationSyntax extends SyntaxNode implements IClassElementSyntax {
         public modifiers: ISyntaxToken[];
@@ -413,6 +880,27 @@ module TypeScript.Syntax.Concrete {
             indexSignature.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.IndexMemberDeclaration;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.indexSignature;
+                case 2: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitIndexMemberDeclaration(this);
+        }
     }
     export class GetAccessorSyntax extends SyntaxNode implements IMemberDeclarationSyntax, IPropertyAssignmentSyntax {
         public modifiers: ISyntaxToken[];
@@ -434,6 +922,29 @@ module TypeScript.Syntax.Concrete {
             callSignature.parent = this,
             block.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.GetAccessor;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.getKeyword;
+                case 2: return this.propertyName;
+                case 3: return this.callSignature;
+                case 4: return this.block;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitGetAccessor(this);
+        }
     }
     export class SetAccessorSyntax extends SyntaxNode implements IMemberDeclarationSyntax, IPropertyAssignmentSyntax {
         public modifiers: ISyntaxToken[];
@@ -455,6 +966,29 @@ module TypeScript.Syntax.Concrete {
             callSignature.parent = this,
             block.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.SetAccessor;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.setKeyword;
+                case 2: return this.propertyName;
+                case 3: return this.callSignature;
+                case 4: return this.block;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitSetAccessor(this);
+        }
     }
     export class PropertySignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
         public propertyName: ISyntaxToken;
@@ -470,6 +1004,27 @@ module TypeScript.Syntax.Concrete {
             questionToken && (questionToken.parent = this),
             typeAnnotation && (typeAnnotation.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.PropertySignature;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.propertyName;
+                case 1: return this.questionToken;
+                case 2: return this.typeAnnotation;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitPropertySignature(this);
+        }
     }
     export class CallSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
         public typeParameterList: TypeParameterListSyntax;
@@ -485,6 +1040,27 @@ module TypeScript.Syntax.Concrete {
             parameterList.parent = this,
             typeAnnotation && (typeAnnotation.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.CallSignature;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.typeParameterList;
+                case 1: return this.parameterList;
+                case 2: return this.typeAnnotation;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitCallSignature(this);
+        }
     }
     export class ConstructSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
         public newKeyword: ISyntaxToken;
@@ -497,6 +1073,26 @@ module TypeScript.Syntax.Concrete {
             newKeyword.parent = this,
             callSignature.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ConstructSignature;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.newKeyword;
+                case 1: return this.callSignature;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitConstructSignature(this);
+        }
     }
     export class IndexSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
         public openBracketToken: ISyntaxToken;
@@ -515,6 +1111,28 @@ module TypeScript.Syntax.Concrete {
             closeBracketToken.parent = this,
             typeAnnotation && (typeAnnotation.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.IndexSignature;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openBracketToken;
+                case 1: return this.parameters;
+                case 2: return this.closeBracketToken;
+                case 3: return this.typeAnnotation;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitIndexSignature(this);
+        }
     }
     export class MethodSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
         public propertyName: ISyntaxToken;
@@ -530,6 +1148,27 @@ module TypeScript.Syntax.Concrete {
             questionToken && (questionToken.parent = this),
             callSignature.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.MethodSignature;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.propertyName;
+                case 1: return this.questionToken;
+                case 2: return this.callSignature;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitMethodSignature(this);
+        }
     }
     export class BlockSyntax extends SyntaxNode implements IStatementSyntax {
         public openBraceToken: ISyntaxToken;
@@ -545,6 +1184,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(statements) && (statements.parent = this),
             closeBraceToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.Block;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openBraceToken;
+                case 1: return this.statements;
+                case 2: return this.closeBraceToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitBlock(this);
+        }
     }
     export class IfStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public ifKeyword: ISyntaxToken;
@@ -569,6 +1229,30 @@ module TypeScript.Syntax.Concrete {
             statement.parent = this,
             elseClause && (elseClause.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.IfStatement;
+        }
+
+        public childCount(): number {
+            return 6;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.ifKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.condition;
+                case 3: return this.closeParenToken;
+                case 4: return this.statement;
+                case 5: return this.elseClause;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitIfStatement(this);
+        }
     }
     export class VariableStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public modifiers: ISyntaxToken[];
@@ -584,6 +1268,27 @@ module TypeScript.Syntax.Concrete {
             variableDeclaration.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.VariableStatement;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.modifiers;
+                case 1: return this.variableDeclaration;
+                case 2: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitVariableStatement(this);
+        }
     }
     export class ExpressionStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public expression: IExpressionSyntax;
@@ -596,6 +1301,26 @@ module TypeScript.Syntax.Concrete {
             expression.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ExpressionStatement;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.expression;
+                case 1: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitExpressionStatement(this);
+        }
     }
     export class ReturnStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public returnKeyword: ISyntaxToken;
@@ -611,6 +1336,27 @@ module TypeScript.Syntax.Concrete {
             expression && (expression.parent = this),
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ReturnStatement;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.returnKeyword;
+                case 1: return this.expression;
+                case 2: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitReturnStatement(this);
+        }
     }
     export class SwitchStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public switchKeyword: ISyntaxToken;
@@ -638,6 +1384,31 @@ module TypeScript.Syntax.Concrete {
             !isShared(switchClauses) && (switchClauses.parent = this),
             closeBraceToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.SwitchStatement;
+        }
+
+        public childCount(): number {
+            return 7;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.switchKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.expression;
+                case 3: return this.closeParenToken;
+                case 4: return this.openBraceToken;
+                case 5: return this.switchClauses;
+                case 6: return this.closeBraceToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitSwitchStatement(this);
+        }
     }
     export class BreakStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public breakKeyword: ISyntaxToken;
@@ -653,6 +1424,27 @@ module TypeScript.Syntax.Concrete {
             identifier && (identifier.parent = this),
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.BreakStatement;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.breakKeyword;
+                case 1: return this.identifier;
+                case 2: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitBreakStatement(this);
+        }
     }
     export class ContinueStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public continueKeyword: ISyntaxToken;
@@ -668,6 +1460,27 @@ module TypeScript.Syntax.Concrete {
             identifier && (identifier.parent = this),
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ContinueStatement;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.continueKeyword;
+                case 1: return this.identifier;
+                case 2: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitContinueStatement(this);
+        }
     }
     export class ForStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public forKeyword: ISyntaxToken;
@@ -704,6 +1517,34 @@ module TypeScript.Syntax.Concrete {
             closeParenToken.parent = this,
             statement.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ForStatement;
+        }
+
+        public childCount(): number {
+            return 10;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.forKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.variableDeclaration;
+                case 3: return this.initializer;
+                case 4: return this.firstSemicolonToken;
+                case 5: return this.condition;
+                case 6: return this.secondSemicolonToken;
+                case 7: return this.incrementor;
+                case 8: return this.closeParenToken;
+                case 9: return this.statement;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitForStatement(this);
+        }
     }
     export class ForInStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public forKeyword: ISyntaxToken;
@@ -734,6 +1575,32 @@ module TypeScript.Syntax.Concrete {
             closeParenToken.parent = this,
             statement.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ForInStatement;
+        }
+
+        public childCount(): number {
+            return 8;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.forKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.variableDeclaration;
+                case 3: return this.left;
+                case 4: return this.inKeyword;
+                case 5: return this.expression;
+                case 6: return this.closeParenToken;
+                case 7: return this.statement;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitForInStatement(this);
+        }
     }
     export class EmptyStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public semicolonToken: ISyntaxToken;
@@ -743,6 +1610,25 @@ module TypeScript.Syntax.Concrete {
             this.semicolonToken = semicolonToken,
             semicolonToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.EmptyStatement;
+        }
+
+        public childCount(): number {
+            return 1;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitEmptyStatement(this);
+        }
     }
     export class ThrowStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public throwKeyword: ISyntaxToken;
@@ -758,6 +1644,27 @@ module TypeScript.Syntax.Concrete {
             expression.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ThrowStatement;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.throwKeyword;
+                case 1: return this.expression;
+                case 2: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitThrowStatement(this);
+        }
     }
     export class WhileStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public whileKeyword: ISyntaxToken;
@@ -779,6 +1686,29 @@ module TypeScript.Syntax.Concrete {
             closeParenToken.parent = this,
             statement.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.WhileStatement;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.whileKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.condition;
+                case 3: return this.closeParenToken;
+                case 4: return this.statement;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitWhileStatement(this);
+        }
     }
     export class TryStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public tryKeyword: ISyntaxToken;
@@ -797,6 +1727,28 @@ module TypeScript.Syntax.Concrete {
             catchClause && (catchClause.parent = this),
             finallyClause && (finallyClause.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TryStatement;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.tryKeyword;
+                case 1: return this.block;
+                case 2: return this.catchClause;
+                case 3: return this.finallyClause;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTryStatement(this);
+        }
     }
     export class LabeledStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public identifier: ISyntaxToken;
@@ -812,6 +1764,27 @@ module TypeScript.Syntax.Concrete {
             colonToken.parent = this,
             statement.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.LabeledStatement;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.identifier;
+                case 1: return this.colonToken;
+                case 2: return this.statement;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitLabeledStatement(this);
+        }
     }
     export class DoStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public doKeyword: ISyntaxToken;
@@ -839,6 +1812,31 @@ module TypeScript.Syntax.Concrete {
             closeParenToken.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.DoStatement;
+        }
+
+        public childCount(): number {
+            return 7;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.doKeyword;
+                case 1: return this.statement;
+                case 2: return this.whileKeyword;
+                case 3: return this.openParenToken;
+                case 4: return this.condition;
+                case 5: return this.closeParenToken;
+                case 6: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitDoStatement(this);
+        }
     }
     export class DebuggerStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public debuggerKeyword: ISyntaxToken;
@@ -851,6 +1849,26 @@ module TypeScript.Syntax.Concrete {
             debuggerKeyword.parent = this,
             semicolonToken && (semicolonToken.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.DebuggerStatement;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.debuggerKeyword;
+                case 1: return this.semicolonToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitDebuggerStatement(this);
+        }
     }
     export class WithStatementSyntax extends SyntaxNode implements IStatementSyntax {
         public withKeyword: ISyntaxToken;
@@ -872,6 +1890,29 @@ module TypeScript.Syntax.Concrete {
             closeParenToken.parent = this,
             statement.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.WithStatement;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.withKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.condition;
+                case 3: return this.closeParenToken;
+                case 4: return this.statement;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitWithStatement(this);
+        }
     }
     export class PrefixUnaryExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
         public operatorToken: ISyntaxToken;
@@ -884,6 +1925,26 @@ module TypeScript.Syntax.Concrete {
             operatorToken.parent = this,
             operand.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.PrefixUnaryExpression;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.operatorToken;
+                case 1: return this.operand;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitPrefixUnaryExpression(this);
+        }
     }
     export class DeleteExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
         public deleteKeyword: ISyntaxToken;
@@ -896,6 +1957,26 @@ module TypeScript.Syntax.Concrete {
             deleteKeyword.parent = this,
             expression.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.DeleteExpression;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.deleteKeyword;
+                case 1: return this.expression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitDeleteExpression(this);
+        }
     }
     export class TypeOfExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
         public typeOfKeyword: ISyntaxToken;
@@ -908,6 +1989,26 @@ module TypeScript.Syntax.Concrete {
             typeOfKeyword.parent = this,
             expression.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TypeOfExpression;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.typeOfKeyword;
+                case 1: return this.expression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTypeOfExpression(this);
+        }
     }
     export class VoidExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
         public voidKeyword: ISyntaxToken;
@@ -920,6 +2021,26 @@ module TypeScript.Syntax.Concrete {
             voidKeyword.parent = this,
             expression.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.VoidExpression;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.voidKeyword;
+                case 1: return this.expression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitVoidExpression(this);
+        }
     }
     export class ConditionalExpressionSyntax extends SyntaxNode implements IExpressionSyntax {
         public condition: IExpressionSyntax;
@@ -941,6 +2062,29 @@ module TypeScript.Syntax.Concrete {
             colonToken.parent = this,
             whenFalse.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ConditionalExpression;
+        }
+
+        public childCount(): number {
+            return 5;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.condition;
+                case 1: return this.questionToken;
+                case 2: return this.whenTrue;
+                case 3: return this.colonToken;
+                case 4: return this.whenFalse;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitConditionalExpression(this);
+        }
     }
     export class BinaryExpressionSyntax extends SyntaxNode implements IExpressionSyntax {
         public left: IExpressionSyntax;
@@ -956,6 +2100,27 @@ module TypeScript.Syntax.Concrete {
             operatorToken.parent = this,
             right.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.BinaryExpression;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.left;
+                case 1: return this.operatorToken;
+                case 2: return this.right;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitBinaryExpression(this);
+        }
     }
     export class PostfixUnaryExpressionSyntax extends SyntaxNode implements IPostfixExpressionSyntax {
         public operand: ILeftHandSideExpressionSyntax;
@@ -968,6 +2133,26 @@ module TypeScript.Syntax.Concrete {
             operand.parent = this,
             operatorToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.PostfixUnaryExpression;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.operand;
+                case 1: return this.operatorToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitPostfixUnaryExpression(this);
+        }
     }
     export class MemberAccessExpressionSyntax extends SyntaxNode implements IMemberExpressionSyntax, ICallExpressionSyntax {
         public expression: ILeftHandSideExpressionSyntax;
@@ -983,6 +2168,27 @@ module TypeScript.Syntax.Concrete {
             dotToken.parent = this,
             name.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.MemberAccessExpression;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.expression;
+                case 1: return this.dotToken;
+                case 2: return this.name;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitMemberAccessExpression(this);
+        }
     }
     export class InvocationExpressionSyntax extends SyntaxNode implements ICallExpressionSyntax {
         public expression: ILeftHandSideExpressionSyntax;
@@ -995,6 +2201,26 @@ module TypeScript.Syntax.Concrete {
             expression.parent = this,
             argumentList.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.InvocationExpression;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.expression;
+                case 1: return this.argumentList;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitInvocationExpression(this);
+        }
     }
     export class ArrayLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
         public openBracketToken: ISyntaxToken;
@@ -1010,6 +2236,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(expressions) && (expressions.parent = this),
             closeBracketToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ArrayLiteralExpression;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openBracketToken;
+                case 1: return this.expressions;
+                case 2: return this.closeBracketToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitArrayLiteralExpression(this);
+        }
     }
     export class ObjectLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
         public openBraceToken: ISyntaxToken;
@@ -1025,6 +2272,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(propertyAssignments) && (propertyAssignments.parent = this),
             closeBraceToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ObjectLiteralExpression;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openBraceToken;
+                case 1: return this.propertyAssignments;
+                case 2: return this.closeBraceToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitObjectLiteralExpression(this);
+        }
     }
     export class ObjectCreationExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
         public newKeyword: ISyntaxToken;
@@ -1040,6 +2308,27 @@ module TypeScript.Syntax.Concrete {
             expression.parent = this,
             argumentList && (argumentList.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ObjectCreationExpression;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.newKeyword;
+                case 1: return this.expression;
+                case 2: return this.argumentList;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitObjectCreationExpression(this);
+        }
     }
     export class ParenthesizedExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
         public openParenToken: ISyntaxToken;
@@ -1055,6 +2344,27 @@ module TypeScript.Syntax.Concrete {
             expression.parent = this,
             closeParenToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ParenthesizedExpression;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openParenToken;
+                case 1: return this.expression;
+                case 2: return this.closeParenToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitParenthesizedExpression(this);
+        }
     }
     export class ParenthesizedArrowFunctionExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
         public callSignature: CallSignatureSyntax;
@@ -1073,6 +2383,28 @@ module TypeScript.Syntax.Concrete {
             block && (block.parent = this),
             expression && (expression.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ParenthesizedArrowFunctionExpression;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.callSignature;
+                case 1: return this.equalsGreaterThanToken;
+                case 2: return this.block;
+                case 3: return this.expression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitParenthesizedArrowFunctionExpression(this);
+        }
     }
     export class SimpleArrowFunctionExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
         public parameter: ParameterSyntax;
@@ -1091,6 +2423,28 @@ module TypeScript.Syntax.Concrete {
             block && (block.parent = this),
             expression && (expression.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.SimpleArrowFunctionExpression;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.parameter;
+                case 1: return this.equalsGreaterThanToken;
+                case 2: return this.block;
+                case 3: return this.expression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitSimpleArrowFunctionExpression(this);
+        }
     }
     export class CastExpressionSyntax extends SyntaxNode implements IUnaryExpressionSyntax {
         public lessThanToken: ISyntaxToken;
@@ -1109,6 +2463,28 @@ module TypeScript.Syntax.Concrete {
             greaterThanToken.parent = this,
             expression.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.CastExpression;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.lessThanToken;
+                case 1: return this.type;
+                case 2: return this.greaterThanToken;
+                case 3: return this.expression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitCastExpression(this);
+        }
     }
     export class ElementAccessExpressionSyntax extends SyntaxNode implements IMemberExpressionSyntax, ICallExpressionSyntax {
         public expression: ILeftHandSideExpressionSyntax;
@@ -1127,6 +2503,28 @@ module TypeScript.Syntax.Concrete {
             argumentExpression.parent = this,
             closeBracketToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ElementAccessExpression;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.expression;
+                case 1: return this.openBracketToken;
+                case 2: return this.argumentExpression;
+                case 3: return this.closeBracketToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitElementAccessExpression(this);
+        }
     }
     export class FunctionExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
         public functionKeyword: ISyntaxToken;
@@ -1145,12 +2543,50 @@ module TypeScript.Syntax.Concrete {
             callSignature.parent = this,
             block.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.FunctionExpression;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.functionKeyword;
+                case 1: return this.identifier;
+                case 2: return this.callSignature;
+                case 3: return this.block;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitFunctionExpression(this);
+        }
     }
     export class OmittedExpressionSyntax extends SyntaxNode implements IExpressionSyntax {
         public _expressionBrand: any;
         constructor(data: number) {
             super(data);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.OmittedExpression;
+        }
+
+        public childCount(): number {
+            return 0;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            throw Errors.invalidOperation();
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitOmittedExpression(this);
+        }
     }
     export class VariableDeclarationSyntax extends SyntaxNode {
         public varKeyword: ISyntaxToken;
@@ -1162,6 +2598,26 @@ module TypeScript.Syntax.Concrete {
             varKeyword.parent = this,
             !isShared(variableDeclarators) && (variableDeclarators.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.VariableDeclaration;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.varKeyword;
+                case 1: return this.variableDeclarators;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitVariableDeclaration(this);
+        }
     }
     export class VariableDeclaratorSyntax extends SyntaxNode {
         public propertyName: ISyntaxToken;
@@ -1176,6 +2632,27 @@ module TypeScript.Syntax.Concrete {
             typeAnnotation && (typeAnnotation.parent = this),
             equalsValueClause && (equalsValueClause.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.VariableDeclarator;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.propertyName;
+                case 1: return this.typeAnnotation;
+                case 2: return this.equalsValueClause;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitVariableDeclarator(this);
+        }
     }
     export class ArgumentListSyntax extends SyntaxNode {
         public typeArgumentList: TypeArgumentListSyntax;
@@ -1193,6 +2670,28 @@ module TypeScript.Syntax.Concrete {
             !isShared(_arguments) && (_arguments.parent = this),
             closeParenToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ArgumentList;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.typeArgumentList;
+                case 1: return this.openParenToken;
+                case 2: return this.arguments;
+                case 3: return this.closeParenToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitArgumentList(this);
+        }
     }
     export class ParameterListSyntax extends SyntaxNode {
         public openParenToken: ISyntaxToken;
@@ -1207,6 +2706,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(parameters) && (parameters.parent = this),
             closeParenToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ParameterList;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.openParenToken;
+                case 1: return this.parameters;
+                case 2: return this.closeParenToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitParameterList(this);
+        }
     }
     export class TypeArgumentListSyntax extends SyntaxNode {
         public lessThanToken: ISyntaxToken;
@@ -1221,6 +2741,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(typeArguments) && (typeArguments.parent = this),
             greaterThanToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TypeArgumentList;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.lessThanToken;
+                case 1: return this.typeArguments;
+                case 2: return this.greaterThanToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTypeArgumentList(this);
+        }
     }
     export class TypeParameterListSyntax extends SyntaxNode {
         public lessThanToken: ISyntaxToken;
@@ -1235,6 +2776,27 @@ module TypeScript.Syntax.Concrete {
             !isShared(typeParameters) && (typeParameters.parent = this),
             greaterThanToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TypeParameterList;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.lessThanToken;
+                case 1: return this.typeParameters;
+                case 2: return this.greaterThanToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTypeParameterList(this);
+        }
     }
     export class HeritageClauseSyntax extends SyntaxNode {
         public extendsOrImplementsKeyword: ISyntaxToken;
@@ -1246,6 +2808,26 @@ module TypeScript.Syntax.Concrete {
             extendsOrImplementsKeyword.parent = this,
             !isShared(typeNames) && (typeNames.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.HeritageClause;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.extendsOrImplementsKeyword;
+                case 1: return this.typeNames;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitHeritageClause(this);
+        }
     }
     export class EqualsValueClauseSyntax extends SyntaxNode {
         public equalsToken: ISyntaxToken;
@@ -1257,6 +2839,26 @@ module TypeScript.Syntax.Concrete {
             equalsToken.parent = this,
             value.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.EqualsValueClause;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.equalsToken;
+                case 1: return this.value;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitEqualsValueClause(this);
+        }
     }
     export class CaseSwitchClauseSyntax extends SyntaxNode implements ISwitchClauseSyntax {
         public caseKeyword: ISyntaxToken;
@@ -1275,6 +2877,28 @@ module TypeScript.Syntax.Concrete {
             colonToken.parent = this,
             !isShared(statements) && (statements.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.CaseSwitchClause;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.caseKeyword;
+                case 1: return this.expression;
+                case 2: return this.colonToken;
+                case 3: return this.statements;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitCaseSwitchClause(this);
+        }
     }
     export class DefaultSwitchClauseSyntax extends SyntaxNode implements ISwitchClauseSyntax {
         public defaultKeyword: ISyntaxToken;
@@ -1290,6 +2914,27 @@ module TypeScript.Syntax.Concrete {
             colonToken.parent = this,
             !isShared(statements) && (statements.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.DefaultSwitchClause;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.defaultKeyword;
+                case 1: return this.colonToken;
+                case 2: return this.statements;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitDefaultSwitchClause(this);
+        }
     }
     export class ElseClauseSyntax extends SyntaxNode {
         public elseKeyword: ISyntaxToken;
@@ -1301,6 +2946,26 @@ module TypeScript.Syntax.Concrete {
             elseKeyword.parent = this,
             statement.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ElseClause;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.elseKeyword;
+                case 1: return this.statement;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitElseClause(this);
+        }
     }
     export class CatchClauseSyntax extends SyntaxNode {
         public catchKeyword: ISyntaxToken;
@@ -1324,6 +2989,30 @@ module TypeScript.Syntax.Concrete {
             closeParenToken.parent = this,
             block.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.CatchClause;
+        }
+
+        public childCount(): number {
+            return 6;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.catchKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.identifier;
+                case 3: return this.typeAnnotation;
+                case 4: return this.closeParenToken;
+                case 5: return this.block;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitCatchClause(this);
+        }
     }
     export class FinallyClauseSyntax extends SyntaxNode {
         public finallyKeyword: ISyntaxToken;
@@ -1335,6 +3024,26 @@ module TypeScript.Syntax.Concrete {
             finallyKeyword.parent = this,
             block.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.FinallyClause;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.finallyKeyword;
+                case 1: return this.block;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitFinallyClause(this);
+        }
     }
     export class TypeParameterSyntax extends SyntaxNode {
         public identifier: ISyntaxToken;
@@ -1346,6 +3055,26 @@ module TypeScript.Syntax.Concrete {
             identifier.parent = this,
             constraint && (constraint.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TypeParameter;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.identifier;
+                case 1: return this.constraint;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTypeParameter(this);
+        }
     }
     export class ConstraintSyntax extends SyntaxNode {
         public extendsKeyword: ISyntaxToken;
@@ -1357,6 +3086,26 @@ module TypeScript.Syntax.Concrete {
             extendsKeyword.parent = this,
             typeOrExpression.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.Constraint;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.extendsKeyword;
+                case 1: return this.typeOrExpression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitConstraint(this);
+        }
     }
     export class SimplePropertyAssignmentSyntax extends SyntaxNode implements IPropertyAssignmentSyntax {
         public propertyName: ISyntaxToken;
@@ -1372,6 +3121,27 @@ module TypeScript.Syntax.Concrete {
             colonToken.parent = this,
             expression.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.SimplePropertyAssignment;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.propertyName;
+                case 1: return this.colonToken;
+                case 2: return this.expression;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitSimplePropertyAssignment(this);
+        }
     }
     export class FunctionPropertyAssignmentSyntax extends SyntaxNode implements IPropertyAssignmentSyntax {
         public propertyName: ISyntaxToken;
@@ -1387,6 +3157,27 @@ module TypeScript.Syntax.Concrete {
             callSignature.parent = this,
             block.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.FunctionPropertyAssignment;
+        }
+
+        public childCount(): number {
+            return 3;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.propertyName;
+                case 1: return this.callSignature;
+                case 2: return this.block;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitFunctionPropertyAssignment(this);
+        }
     }
     export class ParameterSyntax extends SyntaxNode {
         public dotDotDotToken: ISyntaxToken;
@@ -1410,6 +3201,30 @@ module TypeScript.Syntax.Concrete {
             typeAnnotation && (typeAnnotation.parent = this),
             equalsValueClause && (equalsValueClause.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.Parameter;
+        }
+
+        public childCount(): number {
+            return 6;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.dotDotDotToken;
+                case 1: return this.modifiers;
+                case 2: return this.identifier;
+                case 3: return this.questionToken;
+                case 4: return this.typeAnnotation;
+                case 5: return this.equalsValueClause;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitParameter(this);
+        }
     }
     export class EnumElementSyntax extends SyntaxNode {
         public propertyName: ISyntaxToken;
@@ -1421,6 +3236,26 @@ module TypeScript.Syntax.Concrete {
             propertyName.parent = this,
             equalsValueClause && (equalsValueClause.parent = this);
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.EnumElement;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.propertyName;
+                case 1: return this.equalsValueClause;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitEnumElement(this);
+        }
     }
     export class TypeAnnotationSyntax extends SyntaxNode {
         public colonToken: ISyntaxToken;
@@ -1432,6 +3267,26 @@ module TypeScript.Syntax.Concrete {
             colonToken.parent = this,
             type.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.TypeAnnotation;
+        }
+
+        public childCount(): number {
+            return 2;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.colonToken;
+                case 1: return this.type;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitTypeAnnotation(this);
+        }
     }
     export class ExternalModuleReferenceSyntax extends SyntaxNode implements IModuleReferenceSyntax {
         public requireKeyword: ISyntaxToken;
@@ -1450,6 +3305,28 @@ module TypeScript.Syntax.Concrete {
             stringLiteral.parent = this,
             closeParenToken.parent = this;
         }
+
+        public kind(): SyntaxKind {
+            return SyntaxKind.ExternalModuleReference;
+        }
+
+        public childCount(): number {
+            return 4;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.requireKeyword;
+                case 1: return this.openParenToken;
+                case 2: return this.stringLiteral;
+                case 3: return this.closeParenToken;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitExternalModuleReference(this);
+        }
     }
     export class ModuleNameModuleReferenceSyntax extends SyntaxNode implements IModuleReferenceSyntax {
         public moduleName: INameSyntax;
@@ -1459,7 +3336,24 @@ module TypeScript.Syntax.Concrete {
             this.moduleName = moduleName,
             moduleName.parent = this;
         }
-    }
 
-    (<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>UnionTypeSyntax).prototype.__kind = SyntaxKind.UnionType, (<any>ParenthesizedTypeSyntax).prototype.__kind = SyntaxKind.ParenthesizedType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>PrefixUnaryExpressionSyntax).prototype.__kind = SyntaxKind.PrefixUnaryExpression, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>BinaryExpressionSyntax).prototype.__kind = SyntaxKind.BinaryExpression, (<any>PostfixUnaryExpressionSyntax).prototype.__kind = SyntaxKind.PostfixUnaryExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kind = SyntaxKind.VariableDeclaration, (<any>VariableDeclaratorSyntax).prototype.__kind = SyntaxKind.VariableDeclarator, (<any>ArgumentListSyntax).prototype.__kind = SyntaxKind.ArgumentList, (<any>ParameterListSyntax).prototype.__kind = SyntaxKind.ParameterList, (<any>TypeArgumentListSyntax).prototype.__kind = SyntaxKind.TypeArgumentList, (<any>TypeParameterListSyntax).prototype.__kind = SyntaxKind.TypeParameterList, (<any>HeritageClauseSyntax).prototype.__kind = SyntaxKind.HeritageClause, (<any>EqualsValueClauseSyntax).prototype.__kind = SyntaxKind.EqualsValueClause, (<any>CaseSwitchClauseSyntax).prototype.__kind = SyntaxKind.CaseSwitchClause, (<any>DefaultSwitchClauseSyntax).prototype.__kind = SyntaxKind.DefaultSwitchClause, (<any>ElseClauseSyntax).prototype.__kind = SyntaxKind.ElseClause, (<any>CatchClauseSyntax).prototype.__kind = SyntaxKind.CatchClause, (<any>FinallyClauseSyntax).prototype.__kind = SyntaxKind.FinallyClause, (<any>TypeParameterSyntax).prototype.__kind = SyntaxKind.TypeParameter, (<any>ConstraintSyntax).prototype.__kind = SyntaxKind.Constraint, (<any>SimplePropertyAssignmentSyntax).prototype.__kind = SyntaxKind.SimplePropertyAssignment, (<any>FunctionPropertyAssignmentSyntax).prototype.__kind = SyntaxKind.FunctionPropertyAssignment, (<any>ParameterSyntax).prototype.__kind = SyntaxKind.Parameter, (<any>EnumElementSyntax).prototype.__kind = SyntaxKind.EnumElement, (<any>TypeAnnotationSyntax).prototype.__kind = SyntaxKind.TypeAnnotation, (<any>ExternalModuleReferenceSyntax).prototype.__kind = SyntaxKind.ExternalModuleReference, (<any>ModuleNameModuleReferenceSyntax).prototype.__kind = SyntaxKind.ModuleNameModuleReference;
+        public kind(): SyntaxKind {
+            return SyntaxKind.ModuleNameModuleReference;
+        }
+
+        public childCount(): number {
+            return 1;
+        }
+
+        public childAt(slot: number): ISyntaxElement {
+            switch (slot) {
+                case 0: return this.moduleName;
+                default: throw Errors.invalidOperation();
+            }
+        }
+
+        public accept(visitor: ISyntaxVisitor): SyntaxKind {
+            return visitor.visitModuleNameModuleReference(this);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxNodes.interfaces.generated.ts b/src/services/syntax/syntaxNodes.interfaces.generated.ts
index 700910c344d..dd3841719fd 100644
--- a/src/services/syntax/syntaxNodes.interfaces.generated.ts
+++ b/src/services/syntax/syntaxNodes.interfaces.generated.ts
@@ -493,8 +493,6 @@ module TypeScript {
         moduleName: INameSyntax;
     }
 
-    export var nodeMetadata: string[][] = [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],["moduleElements","endOfFileToken"],["left","dotToken","right"],["openBraceToken","typeMembers","closeBraceToken"],["typeParameterList","parameterList","equalsGreaterThanToken","type"],["type","openBracketToken","closeBracketToken"],["newKeyword","typeParameterList","parameterList","equalsGreaterThanToken","type"],["name","typeArgumentList"],["typeOfKeyword","name"],["openBracketToken","types","closeBracketToken"],["left","barToken","right"],["openParenToken","type","closeParenToken"],["modifiers","interfaceKeyword","identifier","typeParameterList","heritageClauses","body"],["modifiers","functionKeyword","identifier","callSignature","block","semicolonToken"],["modifiers","moduleKeyword","name","stringLiteral","openBraceToken","moduleElements","closeBraceToken"],["modifiers","classKeyword","identifier","typeParameterList","heritageClauses","openBraceToken","classElements","closeBraceToken"],["modifiers","enumKeyword","identifier","openBraceToken","enumElements","closeBraceToken"],["modifiers","importKeyword","identifier","equalsToken","moduleReference","semicolonToken"],["exportKeyword","equalsToken","identifier","semicolonToken"],["modifiers","propertyName","callSignature","block","semicolonToken"],["modifiers","variableDeclarator","semicolonToken"],["modifiers","constructorKeyword","callSignature","block","semicolonToken"],["modifiers","indexSignature","semicolonToken"],["modifiers","getKeyword","propertyName","callSignature","block"],["modifiers","setKeyword","propertyName","callSignature","block"],["propertyName","questionToken","typeAnnotation"],["typeParameterList","parameterList","typeAnnotation"],["newKeyword","callSignature"],["openBracketToken","parameters","closeBracketToken","typeAnnotation"],["propertyName","questionToken","callSignature"],["openBraceToken","statements","closeBraceToken"],["ifKeyword","openParenToken","condition","closeParenToken","statement","elseClause"],["modifiers","variableDeclaration","semicolonToken"],["expression","semicolonToken"],["returnKeyword","expression","semicolonToken"],["switchKeyword","openParenToken","expression","closeParenToken","openBraceToken","switchClauses","closeBraceToken"],["breakKeyword","identifier","semicolonToken"],["continueKeyword","identifier","semicolonToken"],["forKeyword","openParenToken","variableDeclaration","initializer","firstSemicolonToken","condition","secondSemicolonToken","incrementor","closeParenToken","statement"],["forKeyword","openParenToken","variableDeclaration","left","inKeyword","expression","closeParenToken","statement"],["semicolonToken"],["throwKeyword","expression","semicolonToken"],["whileKeyword","openParenToken","condition","closeParenToken","statement"],["tryKeyword","block","catchClause","finallyClause"],["identifier","colonToken","statement"],["doKeyword","statement","whileKeyword","openParenToken","condition","closeParenToken","semicolonToken"],["debuggerKeyword","semicolonToken"],["withKeyword","openParenToken","condition","closeParenToken","statement"],["operatorToken","operand"],["deleteKeyword","expression"],["typeOfKeyword","expression"],["voidKeyword","expression"],["condition","questionToken","whenTrue","colonToken","whenFalse"],["left","operatorToken","right"],["operand","operatorToken"],["expression","dotToken","name"],["expression","argumentList"],["openBracketToken","expressions","closeBracketToken"],["openBraceToken","propertyAssignments","closeBraceToken"],["newKeyword","expression","argumentList"],["openParenToken","expression","closeParenToken"],["callSignature","equalsGreaterThanToken","block","expression"],["parameter","equalsGreaterThanToken","block","expression"],["lessThanToken","type","greaterThanToken","expression"],["expression","openBracketToken","argumentExpression","closeBracketToken"],["functionKeyword","identifier","callSignature","block"],[],["varKeyword","variableDeclarators"],["propertyName","typeAnnotation","equalsValueClause"],["typeArgumentList","openParenToken","arguments","closeParenToken"],["openParenToken","parameters","closeParenToken"],["lessThanToken","typeArguments","greaterThanToken"],["lessThanToken","typeParameters","greaterThanToken"],["extendsOrImplementsKeyword","typeNames"],["equalsToken","value"],["caseKeyword","expression","colonToken","statements"],["defaultKeyword","colonToken","statements"],["elseKeyword","statement"],["catchKeyword","openParenToken","identifier","typeAnnotation","closeParenToken","block"],["finallyKeyword","block"],["identifier","constraint"],["extendsKeyword","typeOrExpression"],["propertyName","colonToken","expression"],["propertyName","callSignature","block"],["dotDotDotToken","modifiers","identifier","questionToken","typeAnnotation","equalsValueClause"],["propertyName","equalsValueClause"],["colonToken","type"],["requireKeyword","openParenToken","stringLiteral","closeParenToken"],["moduleName"],];
-
     export module Syntax {
         export interface ISyntaxFactory {
             isConcrete: boolean;
diff --git a/src/services/syntax/syntaxToken.ts b/src/services/syntax/syntaxToken.ts
index 857ffde59c0..0ded9c44891 100644
--- a/src/services/syntax/syntaxToken.ts
+++ b/src/services/syntax/syntaxToken.ts
@@ -297,6 +297,10 @@ module TypeScript.Syntax {
             return this._kind;
         }
 
+        public childCount() { return 0 }
+        public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
+        public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
+
         public clone(): ISyntaxToken {
             return new EmptyToken(this.kind());
         }
@@ -352,8 +356,8 @@ module TypeScript.Syntax {
                 }
 
                 // Ok.  We have a parent.  First, find out which slot we're at in the parent.
-                for (var i = 0, n = childCount(parent); i < n; i++) {
-                    if (childAt(parent, i) === current) {
+                for (var i = 0, n = parent.childCount(); i < n; i++) {
+                    if (parent.childAt(i) === current) {
                         break;
                     }
                 }
@@ -362,7 +366,7 @@ module TypeScript.Syntax {
 
                 // Walk backward from this element, looking for a non-zero-width sibling.
                 for (var j = i - 1; j >= 0; j--) {
-                    var sibling = childAt(parent, j);
+                    var sibling = parent.childAt(j);
                     if (sibling && fullWidth(sibling) > 0) {
                         return sibling;
                     }
@@ -435,6 +439,10 @@ module TypeScript.Syntax {
         public kind(): SyntaxKind {
             return this._kind;
         }
+        
+        public childCount() { return 0 }
+        public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
+        public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
 
         public clone(): ISyntaxToken {
             return new RealizedToken(this._fullStart, this.kind(), this._isKeywordConvertedToIdentifier, this._leadingTrivia, this._text, this._trailingTrivia);
@@ -481,6 +489,10 @@ module TypeScript.Syntax {
             this.underlyingToken.setFullStart(fullStart);
         }
 
+        public childCount() { return 0 }
+        public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
+        public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
+
         public fullStart(): number {
             return this.underlyingToken.fullStart();
         }
diff --git a/src/services/syntax/syntaxTree.ts b/src/services/syntax/syntaxTree.ts
index 30aa3d7e979..5d2584f6b61 100644
--- a/src/services/syntax/syntaxTree.ts
+++ b/src/services/syntax/syntaxTree.ts
@@ -255,18 +255,18 @@ module TypeScript {
         private checkForTrailingComma(list: ISyntaxNodeOrToken[]): boolean {
             // If we have at least one child, and we have an even number of children, then that 
             // means we have an illegal trailing separator.
-            if (childCount(list) === 0 || childCount(list) % 2 === 1) {
+            if (list.childCount() === 0 || list.childCount() % 2 === 1) {
                 return false;
             }
 
-            var child = childAt(list, childCount(list) - 1);
+            var child = list.childAt(list.childCount() - 1);
             this.pushDiagnostic(child, DiagnosticCode.Trailing_comma_not_allowed);
 
             return true;
         }
 
         private checkForAtLeastOneElement(parent: ISyntaxElement, list: ISyntaxNodeOrToken[], reportToken: ISyntaxToken, listKind: string): boolean {
-            if (childCount(list) > 0) {
+            if (list.childCount() > 0) {
                 return false;
             }
 
@@ -589,7 +589,7 @@ module TypeScript {
 
         private checkIndexMemberModifiers(node: IndexMemberDeclarationSyntax): boolean {
             if (node.modifiers.length > 0) {
-                this.pushDiagnostic(childAt(node.modifiers, 0), DiagnosticCode.Modifiers_cannot_appear_here);
+                this.pushDiagnostic(node.modifiers.childAt(0), DiagnosticCode.Modifiers_cannot_appear_here);
                 return true;
             }
 
@@ -654,7 +654,7 @@ module TypeScript {
 
         private checkSetAccessorParameter(node: SetAccessorSyntax): boolean {
             var parameters = node.callSignature.parameterList.parameters;
-            if (childCount(parameters) !== 1) {
+            if (parameters.childCount() !== 1) {
                 this.pushDiagnostic(node.propertyName, DiagnosticCode.set_accessor_must_have_exactly_one_parameter);
                 return true;
             }
@@ -710,8 +710,8 @@ module TypeScript {
 
         private checkEnumElements(node: EnumDeclarationSyntax): boolean {
             var previousValueWasComputed = false;
-            for (var i = 0, n = childCount(node.enumElements); i < n; i++) {
-                var child = childAt(node.enumElements, i);
+            for (var i = 0, n = node.enumElements.childCount(); i < n; i++) {
+                var child = node.enumElements.childAt(i);
 
                 if (i % 2 === 0) {
                     var enumElement = <EnumElementSyntax>child;
@@ -1286,7 +1286,7 @@ module TypeScript {
         private checkForDisallowedModifiers(parent: ISyntaxElement, modifiers: ISyntaxToken[]): boolean {
             if (this.inBlock || this.inObjectLiteralExpression) {
                 if (modifiers.length > 0) {
-                    this.pushDiagnostic(childAt(modifiers, 0), DiagnosticCode.Modifiers_cannot_appear_here);
+                    this.pushDiagnostic(modifiers.childAt(0), DiagnosticCode.Modifiers_cannot_appear_here);
                     return true;
                 }
             }
@@ -1334,8 +1334,8 @@ module TypeScript {
         }
 
         private checkListSeparators<T extends ISyntaxNodeOrToken>(parent: ISyntaxElement, list: T[], kind: SyntaxKind): boolean {
-            for (var i = 0, n = childCount(list); i < n; i++) {
-                var child = childAt(list, i);
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var child = list.childAt(i);
                 if (i % 2 === 1 && child.kind() !== kind) {
                     this.pushDiagnostic(child, DiagnosticCode._0_expected, [SyntaxFacts.getText(kind)]);
                 }
diff --git a/src/services/syntax/syntaxVisitor.generated.ts b/src/services/syntax/syntaxVisitor.generated.ts
index 30d3e9ec42c..6a38a81312b 100644
--- a/src/services/syntax/syntaxVisitor.generated.ts
+++ b/src/services/syntax/syntaxVisitor.generated.ts
@@ -3,99 +3,7 @@
 module TypeScript {
     export function visitNodeOrToken(visitor: ISyntaxVisitor, element: ISyntaxNodeOrToken): any {
         if (element === undefined) { return undefined; }
-        if (isToken(element)) { return visitor.visitToken(<ISyntaxToken>element); }
-        switch (element.kind()) {
-            case SyntaxKind.SourceUnit: return visitor.visitSourceUnit(<SourceUnitSyntax>element);
-            case SyntaxKind.QualifiedName: return visitor.visitQualifiedName(<QualifiedNameSyntax>element);
-            case SyntaxKind.ObjectType: return visitor.visitObjectType(<ObjectTypeSyntax>element);
-            case SyntaxKind.FunctionType: return visitor.visitFunctionType(<FunctionTypeSyntax>element);
-            case SyntaxKind.ArrayType: return visitor.visitArrayType(<ArrayTypeSyntax>element);
-            case SyntaxKind.ConstructorType: return visitor.visitConstructorType(<ConstructorTypeSyntax>element);
-            case SyntaxKind.GenericType: return visitor.visitGenericType(<GenericTypeSyntax>element);
-            case SyntaxKind.TypeQuery: return visitor.visitTypeQuery(<TypeQuerySyntax>element);
-            case SyntaxKind.TupleType: return visitor.visitTupleType(<TupleTypeSyntax>element);
-            case SyntaxKind.UnionType: return visitor.visitUnionType(<UnionTypeSyntax>element);
-            case SyntaxKind.ParenthesizedType: return visitor.visitParenthesizedType(<ParenthesizedTypeSyntax>element);
-            case SyntaxKind.InterfaceDeclaration: return visitor.visitInterfaceDeclaration(<InterfaceDeclarationSyntax>element);
-            case SyntaxKind.FunctionDeclaration: return visitor.visitFunctionDeclaration(<FunctionDeclarationSyntax>element);
-            case SyntaxKind.ModuleDeclaration: return visitor.visitModuleDeclaration(<ModuleDeclarationSyntax>element);
-            case SyntaxKind.ClassDeclaration: return visitor.visitClassDeclaration(<ClassDeclarationSyntax>element);
-            case SyntaxKind.EnumDeclaration: return visitor.visitEnumDeclaration(<EnumDeclarationSyntax>element);
-            case SyntaxKind.ImportDeclaration: return visitor.visitImportDeclaration(<ImportDeclarationSyntax>element);
-            case SyntaxKind.ExportAssignment: return visitor.visitExportAssignment(<ExportAssignmentSyntax>element);
-            case SyntaxKind.MemberFunctionDeclaration: return visitor.visitMemberFunctionDeclaration(<MemberFunctionDeclarationSyntax>element);
-            case SyntaxKind.MemberVariableDeclaration: return visitor.visitMemberVariableDeclaration(<MemberVariableDeclarationSyntax>element);
-            case SyntaxKind.ConstructorDeclaration: return visitor.visitConstructorDeclaration(<ConstructorDeclarationSyntax>element);
-            case SyntaxKind.IndexMemberDeclaration: return visitor.visitIndexMemberDeclaration(<IndexMemberDeclarationSyntax>element);
-            case SyntaxKind.GetAccessor: return visitor.visitGetAccessor(<GetAccessorSyntax>element);
-            case SyntaxKind.SetAccessor: return visitor.visitSetAccessor(<SetAccessorSyntax>element);
-            case SyntaxKind.PropertySignature: return visitor.visitPropertySignature(<PropertySignatureSyntax>element);
-            case SyntaxKind.CallSignature: return visitor.visitCallSignature(<CallSignatureSyntax>element);
-            case SyntaxKind.ConstructSignature: return visitor.visitConstructSignature(<ConstructSignatureSyntax>element);
-            case SyntaxKind.IndexSignature: return visitor.visitIndexSignature(<IndexSignatureSyntax>element);
-            case SyntaxKind.MethodSignature: return visitor.visitMethodSignature(<MethodSignatureSyntax>element);
-            case SyntaxKind.Block: return visitor.visitBlock(<BlockSyntax>element);
-            case SyntaxKind.IfStatement: return visitor.visitIfStatement(<IfStatementSyntax>element);
-            case SyntaxKind.VariableStatement: return visitor.visitVariableStatement(<VariableStatementSyntax>element);
-            case SyntaxKind.ExpressionStatement: return visitor.visitExpressionStatement(<ExpressionStatementSyntax>element);
-            case SyntaxKind.ReturnStatement: return visitor.visitReturnStatement(<ReturnStatementSyntax>element);
-            case SyntaxKind.SwitchStatement: return visitor.visitSwitchStatement(<SwitchStatementSyntax>element);
-            case SyntaxKind.BreakStatement: return visitor.visitBreakStatement(<BreakStatementSyntax>element);
-            case SyntaxKind.ContinueStatement: return visitor.visitContinueStatement(<ContinueStatementSyntax>element);
-            case SyntaxKind.ForStatement: return visitor.visitForStatement(<ForStatementSyntax>element);
-            case SyntaxKind.ForInStatement: return visitor.visitForInStatement(<ForInStatementSyntax>element);
-            case SyntaxKind.EmptyStatement: return visitor.visitEmptyStatement(<EmptyStatementSyntax>element);
-            case SyntaxKind.ThrowStatement: return visitor.visitThrowStatement(<ThrowStatementSyntax>element);
-            case SyntaxKind.WhileStatement: return visitor.visitWhileStatement(<WhileStatementSyntax>element);
-            case SyntaxKind.TryStatement: return visitor.visitTryStatement(<TryStatementSyntax>element);
-            case SyntaxKind.LabeledStatement: return visitor.visitLabeledStatement(<LabeledStatementSyntax>element);
-            case SyntaxKind.DoStatement: return visitor.visitDoStatement(<DoStatementSyntax>element);
-            case SyntaxKind.DebuggerStatement: return visitor.visitDebuggerStatement(<DebuggerStatementSyntax>element);
-            case SyntaxKind.WithStatement: return visitor.visitWithStatement(<WithStatementSyntax>element);
-            case SyntaxKind.PrefixUnaryExpression: return visitor.visitPrefixUnaryExpression(<PrefixUnaryExpressionSyntax>element);
-            case SyntaxKind.DeleteExpression: return visitor.visitDeleteExpression(<DeleteExpressionSyntax>element);
-            case SyntaxKind.TypeOfExpression: return visitor.visitTypeOfExpression(<TypeOfExpressionSyntax>element);
-            case SyntaxKind.VoidExpression: return visitor.visitVoidExpression(<VoidExpressionSyntax>element);
-            case SyntaxKind.ConditionalExpression: return visitor.visitConditionalExpression(<ConditionalExpressionSyntax>element);
-            case SyntaxKind.BinaryExpression: return visitor.visitBinaryExpression(<BinaryExpressionSyntax>element);
-            case SyntaxKind.PostfixUnaryExpression: return visitor.visitPostfixUnaryExpression(<PostfixUnaryExpressionSyntax>element);
-            case SyntaxKind.MemberAccessExpression: return visitor.visitMemberAccessExpression(<MemberAccessExpressionSyntax>element);
-            case SyntaxKind.InvocationExpression: return visitor.visitInvocationExpression(<InvocationExpressionSyntax>element);
-            case SyntaxKind.ArrayLiteralExpression: return visitor.visitArrayLiteralExpression(<ArrayLiteralExpressionSyntax>element);
-            case SyntaxKind.ObjectLiteralExpression: return visitor.visitObjectLiteralExpression(<ObjectLiteralExpressionSyntax>element);
-            case SyntaxKind.ObjectCreationExpression: return visitor.visitObjectCreationExpression(<ObjectCreationExpressionSyntax>element);
-            case SyntaxKind.ParenthesizedExpression: return visitor.visitParenthesizedExpression(<ParenthesizedExpressionSyntax>element);
-            case SyntaxKind.ParenthesizedArrowFunctionExpression: return visitor.visitParenthesizedArrowFunctionExpression(<ParenthesizedArrowFunctionExpressionSyntax>element);
-            case SyntaxKind.SimpleArrowFunctionExpression: return visitor.visitSimpleArrowFunctionExpression(<SimpleArrowFunctionExpressionSyntax>element);
-            case SyntaxKind.CastExpression: return visitor.visitCastExpression(<CastExpressionSyntax>element);
-            case SyntaxKind.ElementAccessExpression: return visitor.visitElementAccessExpression(<ElementAccessExpressionSyntax>element);
-            case SyntaxKind.FunctionExpression: return visitor.visitFunctionExpression(<FunctionExpressionSyntax>element);
-            case SyntaxKind.OmittedExpression: return visitor.visitOmittedExpression(<OmittedExpressionSyntax>element);
-            case SyntaxKind.VariableDeclaration: return visitor.visitVariableDeclaration(<VariableDeclarationSyntax>element);
-            case SyntaxKind.VariableDeclarator: return visitor.visitVariableDeclarator(<VariableDeclaratorSyntax>element);
-            case SyntaxKind.ArgumentList: return visitor.visitArgumentList(<ArgumentListSyntax>element);
-            case SyntaxKind.ParameterList: return visitor.visitParameterList(<ParameterListSyntax>element);
-            case SyntaxKind.TypeArgumentList: return visitor.visitTypeArgumentList(<TypeArgumentListSyntax>element);
-            case SyntaxKind.TypeParameterList: return visitor.visitTypeParameterList(<TypeParameterListSyntax>element);
-            case SyntaxKind.HeritageClause: return visitor.visitHeritageClause(<HeritageClauseSyntax>element);
-            case SyntaxKind.EqualsValueClause: return visitor.visitEqualsValueClause(<EqualsValueClauseSyntax>element);
-            case SyntaxKind.CaseSwitchClause: return visitor.visitCaseSwitchClause(<CaseSwitchClauseSyntax>element);
-            case SyntaxKind.DefaultSwitchClause: return visitor.visitDefaultSwitchClause(<DefaultSwitchClauseSyntax>element);
-            case SyntaxKind.ElseClause: return visitor.visitElseClause(<ElseClauseSyntax>element);
-            case SyntaxKind.CatchClause: return visitor.visitCatchClause(<CatchClauseSyntax>element);
-            case SyntaxKind.FinallyClause: return visitor.visitFinallyClause(<FinallyClauseSyntax>element);
-            case SyntaxKind.TypeParameter: return visitor.visitTypeParameter(<TypeParameterSyntax>element);
-            case SyntaxKind.Constraint: return visitor.visitConstraint(<ConstraintSyntax>element);
-            case SyntaxKind.SimplePropertyAssignment: return visitor.visitSimplePropertyAssignment(<SimplePropertyAssignmentSyntax>element);
-            case SyntaxKind.FunctionPropertyAssignment: return visitor.visitFunctionPropertyAssignment(<FunctionPropertyAssignmentSyntax>element);
-            case SyntaxKind.Parameter: return visitor.visitParameter(<ParameterSyntax>element);
-            case SyntaxKind.EnumElement: return visitor.visitEnumElement(<EnumElementSyntax>element);
-            case SyntaxKind.TypeAnnotation: return visitor.visitTypeAnnotation(<TypeAnnotationSyntax>element);
-            case SyntaxKind.ExternalModuleReference: return visitor.visitExternalModuleReference(<ExternalModuleReferenceSyntax>element);
-            case SyntaxKind.ModuleNameModuleReference: return visitor.visitModuleNameModuleReference(<ModuleNameModuleReferenceSyntax>element);
-        }
-
-        throw Errors.invalidOperation();
+        return element.accept(visitor);
     }
 
     export interface ISyntaxVisitor {
diff --git a/src/services/syntax/syntaxWalker.generated.ts b/src/services/syntax/syntaxWalker.generated.ts
index a50672d2c37..b1ba8d53821 100644
--- a/src/services/syntax/syntaxWalker.generated.ts
+++ b/src/services/syntax/syntaxWalker.generated.ts
@@ -13,16 +13,24 @@ module TypeScript {
             this.visitToken(token);
         }
 
+        private visitOptionalNode(node: ISyntaxNode): void {
+            if (node === undefined) {
+                return;
+            }
+
+            node.accept(this);
+        }
+
         public visitList(list: ISyntaxNodeOrToken[]): void {
             for (var i = 0, n = list.length; i < n; i++) {
-               visitNodeOrToken(this, list[i]);
+                list[i].accept(this);
             }
         }
 
         public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {
             for (var i = 0, n = list.separatedListLength; i < n; i++) {
                 if (i % 2 === 0) {
-                    visitNodeOrToken(this, list[i >> 1]);
+                    list[i >> 1].accept(this);
                 }
                 else {
                     this.visitToken(list.separators[i >> 1]);
@@ -36,7 +44,7 @@ module TypeScript {
         }
 
         public visitQualifiedName(node: QualifiedNameSyntax): void {
-            visitNodeOrToken(this, node.left);
+            node.left.accept(this);
             this.visitToken(node.dotToken);
             this.visitToken(node.right);
         }
@@ -48,34 +56,34 @@ module TypeScript {
         }
 
         public visitFunctionType(node: FunctionTypeSyntax): void {
-            visitNodeOrToken(this, node.typeParameterList);
-            visitNodeOrToken(this, node.parameterList);
+            this.visitOptionalNode(node.typeParameterList);
+            node.parameterList.accept(this);
             this.visitToken(node.equalsGreaterThanToken);
-            visitNodeOrToken(this, node.type);
+            node.type.accept(this);
         }
 
         public visitArrayType(node: ArrayTypeSyntax): void {
-            visitNodeOrToken(this, node.type);
+            node.type.accept(this);
             this.visitToken(node.openBracketToken);
             this.visitToken(node.closeBracketToken);
         }
 
         public visitConstructorType(node: ConstructorTypeSyntax): void {
             this.visitToken(node.newKeyword);
-            visitNodeOrToken(this, node.typeParameterList);
-            visitNodeOrToken(this, node.parameterList);
+            this.visitOptionalNode(node.typeParameterList);
+            node.parameterList.accept(this);
             this.visitToken(node.equalsGreaterThanToken);
-            visitNodeOrToken(this, node.type);
+            node.type.accept(this);
         }
 
         public visitGenericType(node: GenericTypeSyntax): void {
-            visitNodeOrToken(this, node.name);
-            visitNodeOrToken(this, node.typeArgumentList);
+            node.name.accept(this);
+            node.typeArgumentList.accept(this);
         }
 
         public visitTypeQuery(node: TypeQuerySyntax): void {
             this.visitToken(node.typeOfKeyword);
-            visitNodeOrToken(this, node.name);
+            node.name.accept(this);
         }
 
         public visitTupleType(node: TupleTypeSyntax): void {
@@ -85,14 +93,14 @@ module TypeScript {
         }
 
         public visitUnionType(node: UnionTypeSyntax): void {
-            visitNodeOrToken(this, node.left);
+            node.left.accept(this);
             this.visitToken(node.barToken);
-            visitNodeOrToken(this, node.right);
+            node.right.accept(this);
         }
 
         public visitParenthesizedType(node: ParenthesizedTypeSyntax): void {
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.type);
+            node.type.accept(this);
             this.visitToken(node.closeParenToken);
         }
 
@@ -100,17 +108,17 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.interfaceKeyword);
             this.visitToken(node.identifier);
-            visitNodeOrToken(this, node.typeParameterList);
+            this.visitOptionalNode(node.typeParameterList);
             this.visitList(node.heritageClauses);
-            visitNodeOrToken(this, node.body);
+            node.body.accept(this);
         }
 
         public visitFunctionDeclaration(node: FunctionDeclarationSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.functionKeyword);
             this.visitToken(node.identifier);
-            visitNodeOrToken(this, node.callSignature);
-            visitNodeOrToken(this, node.block);
+            node.callSignature.accept(this);
+            this.visitOptionalNode(node.block);
             this.visitOptionalToken(node.semicolonToken);
         }
 
@@ -128,7 +136,7 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.classKeyword);
             this.visitToken(node.identifier);
-            visitNodeOrToken(this, node.typeParameterList);
+            this.visitOptionalNode(node.typeParameterList);
             this.visitList(node.heritageClauses);
             this.visitToken(node.openBraceToken);
             this.visitList(node.classElements);
@@ -149,7 +157,7 @@ module TypeScript {
             this.visitToken(node.importKeyword);
             this.visitToken(node.identifier);
             this.visitToken(node.equalsToken);
-            visitNodeOrToken(this, node.moduleReference);
+            node.moduleReference.accept(this);
             this.visitOptionalToken(node.semicolonToken);
         }
 
@@ -163,28 +171,28 @@ module TypeScript {
         public visitMemberFunctionDeclaration(node: MemberFunctionDeclarationSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.propertyName);
-            visitNodeOrToken(this, node.callSignature);
-            visitNodeOrToken(this, node.block);
+            node.callSignature.accept(this);
+            this.visitOptionalNode(node.block);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitMemberVariableDeclaration(node: MemberVariableDeclarationSyntax): void {
             this.visitList(node.modifiers);
-            visitNodeOrToken(this, node.variableDeclarator);
+            node.variableDeclarator.accept(this);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitConstructorDeclaration(node: ConstructorDeclarationSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.constructorKeyword);
-            visitNodeOrToken(this, node.callSignature);
-            visitNodeOrToken(this, node.block);
+            node.callSignature.accept(this);
+            this.visitOptionalNode(node.block);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitIndexMemberDeclaration(node: IndexMemberDeclarationSyntax): void {
             this.visitList(node.modifiers);
-            visitNodeOrToken(this, node.indexSignature);
+            node.indexSignature.accept(this);
             this.visitOptionalToken(node.semicolonToken);
         }
 
@@ -192,46 +200,46 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.getKeyword);
             this.visitToken(node.propertyName);
-            visitNodeOrToken(this, node.callSignature);
-            visitNodeOrToken(this, node.block);
+            node.callSignature.accept(this);
+            node.block.accept(this);
         }
 
         public visitSetAccessor(node: SetAccessorSyntax): void {
             this.visitList(node.modifiers);
             this.visitToken(node.setKeyword);
             this.visitToken(node.propertyName);
-            visitNodeOrToken(this, node.callSignature);
-            visitNodeOrToken(this, node.block);
+            node.callSignature.accept(this);
+            node.block.accept(this);
         }
 
         public visitPropertySignature(node: PropertySignatureSyntax): void {
             this.visitToken(node.propertyName);
             this.visitOptionalToken(node.questionToken);
-            visitNodeOrToken(this, node.typeAnnotation);
+            this.visitOptionalNode(node.typeAnnotation);
         }
 
         public visitCallSignature(node: CallSignatureSyntax): void {
-            visitNodeOrToken(this, node.typeParameterList);
-            visitNodeOrToken(this, node.parameterList);
-            visitNodeOrToken(this, node.typeAnnotation);
+            this.visitOptionalNode(node.typeParameterList);
+            node.parameterList.accept(this);
+            this.visitOptionalNode(node.typeAnnotation);
         }
 
         public visitConstructSignature(node: ConstructSignatureSyntax): void {
             this.visitToken(node.newKeyword);
-            visitNodeOrToken(this, node.callSignature);
+            node.callSignature.accept(this);
         }
 
         public visitIndexSignature(node: IndexSignatureSyntax): void {
             this.visitToken(node.openBracketToken);
             this.visitSeparatedList(node.parameters);
             this.visitToken(node.closeBracketToken);
-            visitNodeOrToken(this, node.typeAnnotation);
+            this.visitOptionalNode(node.typeAnnotation);
         }
 
         public visitMethodSignature(node: MethodSignatureSyntax): void {
             this.visitToken(node.propertyName);
             this.visitOptionalToken(node.questionToken);
-            visitNodeOrToken(this, node.callSignature);
+            node.callSignature.accept(this);
         }
 
         public visitBlock(node: BlockSyntax): void {
@@ -243,20 +251,20 @@ module TypeScript {
         public visitIfStatement(node: IfStatementSyntax): void {
             this.visitToken(node.ifKeyword);
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.condition);
+            node.condition.accept(this);
             this.visitToken(node.closeParenToken);
-            visitNodeOrToken(this, node.statement);
-            visitNodeOrToken(this, node.elseClause);
+            node.statement.accept(this);
+            this.visitOptionalNode(node.elseClause);
         }
 
         public visitVariableStatement(node: VariableStatementSyntax): void {
             this.visitList(node.modifiers);
-            visitNodeOrToken(this, node.variableDeclaration);
+            node.variableDeclaration.accept(this);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitExpressionStatement(node: ExpressionStatementSyntax): void {
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitOptionalToken(node.semicolonToken);
         }
 
@@ -269,7 +277,7 @@ module TypeScript {
         public visitSwitchStatement(node: SwitchStatementSyntax): void {
             this.visitToken(node.switchKeyword);
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitToken(node.closeParenToken);
             this.visitToken(node.openBraceToken);
             this.visitList(node.switchClauses);
@@ -291,25 +299,25 @@ module TypeScript {
         public visitForStatement(node: ForStatementSyntax): void {
             this.visitToken(node.forKeyword);
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.variableDeclaration);
+            this.visitOptionalNode(node.variableDeclaration);
             visitNodeOrToken(this, node.initializer);
             this.visitToken(node.firstSemicolonToken);
             visitNodeOrToken(this, node.condition);
             this.visitToken(node.secondSemicolonToken);
             visitNodeOrToken(this, node.incrementor);
             this.visitToken(node.closeParenToken);
-            visitNodeOrToken(this, node.statement);
+            node.statement.accept(this);
         }
 
         public visitForInStatement(node: ForInStatementSyntax): void {
             this.visitToken(node.forKeyword);
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.variableDeclaration);
+            this.visitOptionalNode(node.variableDeclaration);
             visitNodeOrToken(this, node.left);
             this.visitToken(node.inKeyword);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitToken(node.closeParenToken);
-            visitNodeOrToken(this, node.statement);
+            node.statement.accept(this);
         }
 
         public visitEmptyStatement(node: EmptyStatementSyntax): void {
@@ -318,37 +326,37 @@ module TypeScript {
 
         public visitThrowStatement(node: ThrowStatementSyntax): void {
             this.visitToken(node.throwKeyword);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitOptionalToken(node.semicolonToken);
         }
 
         public visitWhileStatement(node: WhileStatementSyntax): void {
             this.visitToken(node.whileKeyword);
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.condition);
+            node.condition.accept(this);
             this.visitToken(node.closeParenToken);
-            visitNodeOrToken(this, node.statement);
+            node.statement.accept(this);
         }
 
         public visitTryStatement(node: TryStatementSyntax): void {
             this.visitToken(node.tryKeyword);
-            visitNodeOrToken(this, node.block);
-            visitNodeOrToken(this, node.catchClause);
-            visitNodeOrToken(this, node.finallyClause);
+            node.block.accept(this);
+            this.visitOptionalNode(node.catchClause);
+            this.visitOptionalNode(node.finallyClause);
         }
 
         public visitLabeledStatement(node: LabeledStatementSyntax): void {
             this.visitToken(node.identifier);
             this.visitToken(node.colonToken);
-            visitNodeOrToken(this, node.statement);
+            node.statement.accept(this);
         }
 
         public visitDoStatement(node: DoStatementSyntax): void {
             this.visitToken(node.doKeyword);
-            visitNodeOrToken(this, node.statement);
+            node.statement.accept(this);
             this.visitToken(node.whileKeyword);
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.condition);
+            node.condition.accept(this);
             this.visitToken(node.closeParenToken);
             this.visitOptionalToken(node.semicolonToken);
         }
@@ -361,59 +369,59 @@ module TypeScript {
         public visitWithStatement(node: WithStatementSyntax): void {
             this.visitToken(node.withKeyword);
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.condition);
+            node.condition.accept(this);
             this.visitToken(node.closeParenToken);
-            visitNodeOrToken(this, node.statement);
+            node.statement.accept(this);
         }
 
         public visitPrefixUnaryExpression(node: PrefixUnaryExpressionSyntax): void {
             this.visitToken(node.operatorToken);
-            visitNodeOrToken(this, node.operand);
+            node.operand.accept(this);
         }
 
         public visitDeleteExpression(node: DeleteExpressionSyntax): void {
             this.visitToken(node.deleteKeyword);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
         }
 
         public visitTypeOfExpression(node: TypeOfExpressionSyntax): void {
             this.visitToken(node.typeOfKeyword);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
         }
 
         public visitVoidExpression(node: VoidExpressionSyntax): void {
             this.visitToken(node.voidKeyword);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
         }
 
         public visitConditionalExpression(node: ConditionalExpressionSyntax): void {
-            visitNodeOrToken(this, node.condition);
+            node.condition.accept(this);
             this.visitToken(node.questionToken);
-            visitNodeOrToken(this, node.whenTrue);
+            node.whenTrue.accept(this);
             this.visitToken(node.colonToken);
-            visitNodeOrToken(this, node.whenFalse);
+            node.whenFalse.accept(this);
         }
 
         public visitBinaryExpression(node: BinaryExpressionSyntax): void {
-            visitNodeOrToken(this, node.left);
+            node.left.accept(this);
             this.visitToken(node.operatorToken);
-            visitNodeOrToken(this, node.right);
+            node.right.accept(this);
         }
 
         public visitPostfixUnaryExpression(node: PostfixUnaryExpressionSyntax): void {
-            visitNodeOrToken(this, node.operand);
+            node.operand.accept(this);
             this.visitToken(node.operatorToken);
         }
 
         public visitMemberAccessExpression(node: MemberAccessExpressionSyntax): void {
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitToken(node.dotToken);
             this.visitToken(node.name);
         }
 
         public visitInvocationExpression(node: InvocationExpressionSyntax): void {
-            visitNodeOrToken(this, node.expression);
-            visitNodeOrToken(this, node.argumentList);
+            node.expression.accept(this);
+            node.argumentList.accept(this);
         }
 
         public visitArrayLiteralExpression(node: ArrayLiteralExpressionSyntax): void {
@@ -430,49 +438,49 @@ module TypeScript {
 
         public visitObjectCreationExpression(node: ObjectCreationExpressionSyntax): void {
             this.visitToken(node.newKeyword);
-            visitNodeOrToken(this, node.expression);
-            visitNodeOrToken(this, node.argumentList);
+            node.expression.accept(this);
+            this.visitOptionalNode(node.argumentList);
         }
 
         public visitParenthesizedExpression(node: ParenthesizedExpressionSyntax): void {
             this.visitToken(node.openParenToken);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitToken(node.closeParenToken);
         }
 
         public visitParenthesizedArrowFunctionExpression(node: ParenthesizedArrowFunctionExpressionSyntax): void {
-            visitNodeOrToken(this, node.callSignature);
+            node.callSignature.accept(this);
             this.visitToken(node.equalsGreaterThanToken);
-            visitNodeOrToken(this, node.block);
+            this.visitOptionalNode(node.block);
             visitNodeOrToken(this, node.expression);
         }
 
         public visitSimpleArrowFunctionExpression(node: SimpleArrowFunctionExpressionSyntax): void {
-            visitNodeOrToken(this, node.parameter);
+            node.parameter.accept(this);
             this.visitToken(node.equalsGreaterThanToken);
-            visitNodeOrToken(this, node.block);
+            this.visitOptionalNode(node.block);
             visitNodeOrToken(this, node.expression);
         }
 
         public visitCastExpression(node: CastExpressionSyntax): void {
             this.visitToken(node.lessThanToken);
-            visitNodeOrToken(this, node.type);
+            node.type.accept(this);
             this.visitToken(node.greaterThanToken);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
         }
 
         public visitElementAccessExpression(node: ElementAccessExpressionSyntax): void {
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitToken(node.openBracketToken);
-            visitNodeOrToken(this, node.argumentExpression);
+            node.argumentExpression.accept(this);
             this.visitToken(node.closeBracketToken);
         }
 
         public visitFunctionExpression(node: FunctionExpressionSyntax): void {
             this.visitToken(node.functionKeyword);
             this.visitOptionalToken(node.identifier);
-            visitNodeOrToken(this, node.callSignature);
-            visitNodeOrToken(this, node.block);
+            node.callSignature.accept(this);
+            node.block.accept(this);
         }
 
         public visitOmittedExpression(node: OmittedExpressionSyntax): void {
@@ -485,12 +493,12 @@ module TypeScript {
 
         public visitVariableDeclarator(node: VariableDeclaratorSyntax): void {
             this.visitToken(node.propertyName);
-            visitNodeOrToken(this, node.typeAnnotation);
-            visitNodeOrToken(this, node.equalsValueClause);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitOptionalNode(node.equalsValueClause);
         }
 
         public visitArgumentList(node: ArgumentListSyntax): void {
-            visitNodeOrToken(this, node.typeArgumentList);
+            this.visitOptionalNode(node.typeArgumentList);
             this.visitToken(node.openParenToken);
             this.visitSeparatedList(node.arguments);
             this.visitToken(node.closeParenToken);
@@ -521,12 +529,12 @@ module TypeScript {
 
         public visitEqualsValueClause(node: EqualsValueClauseSyntax): void {
             this.visitToken(node.equalsToken);
-            visitNodeOrToken(this, node.value);
+            node.value.accept(this);
         }
 
         public visitCaseSwitchClause(node: CaseSwitchClauseSyntax): void {
             this.visitToken(node.caseKeyword);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
             this.visitToken(node.colonToken);
             this.visitList(node.statements);
         }
@@ -539,43 +547,43 @@ module TypeScript {
 
         public visitElseClause(node: ElseClauseSyntax): void {
             this.visitToken(node.elseKeyword);
-            visitNodeOrToken(this, node.statement);
+            node.statement.accept(this);
         }
 
         public visitCatchClause(node: CatchClauseSyntax): void {
             this.visitToken(node.catchKeyword);
             this.visitToken(node.openParenToken);
             this.visitToken(node.identifier);
-            visitNodeOrToken(this, node.typeAnnotation);
+            this.visitOptionalNode(node.typeAnnotation);
             this.visitToken(node.closeParenToken);
-            visitNodeOrToken(this, node.block);
+            node.block.accept(this);
         }
 
         public visitFinallyClause(node: FinallyClauseSyntax): void {
             this.visitToken(node.finallyKeyword);
-            visitNodeOrToken(this, node.block);
+            node.block.accept(this);
         }
 
         public visitTypeParameter(node: TypeParameterSyntax): void {
             this.visitToken(node.identifier);
-            visitNodeOrToken(this, node.constraint);
+            this.visitOptionalNode(node.constraint);
         }
 
         public visitConstraint(node: ConstraintSyntax): void {
             this.visitToken(node.extendsKeyword);
-            visitNodeOrToken(this, node.typeOrExpression);
+            node.typeOrExpression.accept(this);
         }
 
         public visitSimplePropertyAssignment(node: SimplePropertyAssignmentSyntax): void {
             this.visitToken(node.propertyName);
             this.visitToken(node.colonToken);
-            visitNodeOrToken(this, node.expression);
+            node.expression.accept(this);
         }
 
         public visitFunctionPropertyAssignment(node: FunctionPropertyAssignmentSyntax): void {
             this.visitToken(node.propertyName);
-            visitNodeOrToken(this, node.callSignature);
-            visitNodeOrToken(this, node.block);
+            node.callSignature.accept(this);
+            node.block.accept(this);
         }
 
         public visitParameter(node: ParameterSyntax): void {
@@ -583,18 +591,18 @@ module TypeScript {
             this.visitList(node.modifiers);
             this.visitToken(node.identifier);
             this.visitOptionalToken(node.questionToken);
-            visitNodeOrToken(this, node.typeAnnotation);
-            visitNodeOrToken(this, node.equalsValueClause);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitOptionalNode(node.equalsValueClause);
         }
 
         public visitEnumElement(node: EnumElementSyntax): void {
             this.visitToken(node.propertyName);
-            visitNodeOrToken(this, node.equalsValueClause);
+            this.visitOptionalNode(node.equalsValueClause);
         }
 
         public visitTypeAnnotation(node: TypeAnnotationSyntax): void {
             this.visitToken(node.colonToken);
-            visitNodeOrToken(this, node.type);
+            node.type.accept(this);
         }
 
         public visitExternalModuleReference(node: ExternalModuleReferenceSyntax): void {
@@ -605,7 +613,7 @@ module TypeScript {
         }
 
         public visitModuleNameModuleReference(node: ModuleNameModuleReferenceSyntax): void {
-            visitNodeOrToken(this, node.moduleName);
+            node.moduleName.accept(this);
         }
     }
 }
\ No newline at end of file
diff --git a/src/services/syntax/testUtilities.ts b/src/services/syntax/testUtilities.ts
index 6144c6cffb7..18853a64464 100644
--- a/src/services/syntax/testUtilities.ts
+++ b/src/services/syntax/testUtilities.ts
@@ -13,11 +13,11 @@ module TypeScript {
         Debug.assert(node2.kind() === TypeScript.SyntaxKind.SourceUnit || node2.parent);
 
         if (node1.kind() !== node2.kind()) { return false; }
-        if (childCount(node1) !== childCount(node2)) { return false; }
+        if (node1.childCount() !== node2.childCount()) { return false; }
 
-        for (var i = 0, n = childCount(node1); i < n; i++) {
-            var element1 = childAt(node1, i);
-            var element2 = childAt(node2, i);
+        for (var i = 0, n = node1.childCount(); i < n; i++) {
+            var element1 = node1.childAt(i);
+            var element2 = node2.childAt(i);
 
             if (checkParents) {
                 assertParent(node1, element1);
@@ -105,13 +105,13 @@ module TypeScript {
         Debug.assert(TypeScript.isShared(list1) || list1.parent);
         Debug.assert(TypeScript.isShared(list2) || list2.parent);
 
-        if (childCount(list1) !== childCount(list2)) {
+        if (list1.childCount() !== list2.childCount()) {
             return false;
         }
 
-        for (var i = 0, n = childCount(list1); i < n; i++) {
-            var child1 = childAt(list1, i);
-            var child2 = childAt(list2, i);
+        for (var i = 0, n = list1.childCount(); i < n; i++) {
+            var child1 = list1.childAt(i);
+            var child2 = list2.childAt(i);
 
             if (checkParents) {
                 assertParent(list1, child1);
@@ -130,13 +130,13 @@ module TypeScript {
         Debug.assert(TypeScript.isShared(list1) || list1.parent);
         Debug.assert(TypeScript.isShared(list2) || list2.parent);
 
-        if (childCount(list1) !== childCount(list2)) {
+        if (list1.childCount() !== list2.childCount()) {
             return false;
         }
 
-        for (var i = 0, n = childCount(list1); i < n; i++) {
-            var element1 = childAt(list1, i);
-            var element2 = childAt(list2, i);
+        for (var i = 0, n = list1.childCount(); i < n; i++) {
+            var element1 = list1.childAt(i);
+            var element2 = list2.childAt(i);
 
             if (checkParents) {
                 assertParent(list1, element1);
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 5fd90eb894a..2cc5c827b4f 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -197,7 +197,7 @@ module ts {
                 }
             }
 
-            Debug.assert(startNode || n.kind === SyntaxKind.SourceFile);
+            Debug.assert(startNode !== undefined || n.kind === SyntaxKind.SourceFile);
 
             // Here we know that none of child token nodes embrace the position, 
             // the only known case is when position is at the end of the file.
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
new file mode 100644
index 00000000000..a9f4be155d9
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
@@ -0,0 +1,64 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(12,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(14,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(16,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(18,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(20,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(22,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(24,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(24,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts (10 errors) ====
+    interface I {
+        (stringParts: string[], ...rest: boolean[]): I;
+        g: I;
+        h: I;
+        member: I;
+        thisIsNotATag(x: string): void
+        [x: number]: I;
+    }
+    
+    var f: I;
+    
+    f `abc`
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`.member
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`.member;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`["member"];
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`["member"];
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`[0].member `abc${1}def${2}ghi`;
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f.thisIsNotATag(`abc`);
+    
+    f.thisIsNotATag(`abc${1}def${2}ghi`);
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js
new file mode 100644
index 00000000000..db68e950c34
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js
@@ -0,0 +1,45 @@
+//// [taggedTemplateStringsWithIncompatibleTypedTagsES6.ts]
+interface I {
+    (stringParts: string[], ...rest: boolean[]): I;
+    g: I;
+    h: I;
+    member: I;
+    thisIsNotATag(x: string): void
+    [x: number]: I;
+}
+
+var f: I;
+
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
+
+
+//// [taggedTemplateStringsWithIncompatibleTypedTagsES6.js]
+var f;
+f `abc`;
+f `abc${1}def${2}ghi`;
+f `abc`.member;
+f `abc${1}def${2}ghi`.member;
+f `abc`["member"];
+f `abc${1}def${2}ghi`["member"];
+f `abc`[0].member `abc${1}def${2}ghi`;
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+f.thisIsNotATag(`abc`);
+f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types
new file mode 100644
index 00000000000..572c3c1a8d1
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types
@@ -0,0 +1,82 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts ===
+interface I {
+>I : I
+
+    (stringParts: string[], ...rest: boolean[]): I;
+>stringParts : string[]
+>rest : boolean[]
+>I : I
+
+    g: I;
+>g : I
+>I : I
+
+    h: I;
+>h : I
+>I : I
+
+    member: I;
+>member : I
+>I : I
+
+    thisIsNotATag(x: string): void
+>thisIsNotATag : (x: string) => void
+>x : string
+
+    [x: number]: I;
+>x : number
+>I : I
+}
+
+var f: I;
+>f : I
+>I : I
+
+f `abc`
+>f : I
+
+f `abc${1}def${2}ghi`;
+>f : I
+
+f `abc`.member
+>f `abc`.member : any
+>f : I
+>member : any
+
+f `abc${1}def${2}ghi`.member;
+>f `abc${1}def${2}ghi`.member : any
+>f : I
+>member : any
+
+f `abc`["member"];
+>f `abc`["member"] : any
+>f : I
+
+f `abc${1}def${2}ghi`["member"];
+>f `abc${1}def${2}ghi`["member"] : any
+>f : I
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+>f `abc`[0].member : any
+>f `abc`[0] : any
+>f : I
+>member : any
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+>f `abc${1}def${2}ghi`["member"].member : any
+>f `abc${1}def${2}ghi`["member"] : any
+>f : I
+>member : any
+
+f.thisIsNotATag(`abc`);
+>f.thisIsNotATag(`abc`) : void
+>f.thisIsNotATag : (x: string) => void
+>f : I
+>thisIsNotATag : (x: string) => void
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
+>f.thisIsNotATag(`abc${1}def${2}ghi`) : void
+>f.thisIsNotATag : (x: string) => void
+>f : I
+>thisIsNotATag : (x: string) => void
+
diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.errors.txt
new file mode 100644
index 00000000000..4813fe5a239
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts(13,21): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts (1 errors) ====
+    interface I {
+        (strs: string[], subs: number[]): I;
+        member: {
+            new (s: string): {
+                new (n: number): {
+                    new (): boolean;
+                }
+            }
+        };
+    }
+    var f: I;
+    
+    var x = new new new f `abc${ 0 }def`.member("hello")(42) === true;
+                        ~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js
new file mode 100644
index 00000000000..4d6a68a921a
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js
@@ -0,0 +1,20 @@
+//// [taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts]
+interface I {
+    (strs: string[], subs: number[]): I;
+    member: {
+        new (s: string): {
+            new (n: number): {
+                new (): boolean;
+            }
+        }
+    };
+}
+var f: I;
+
+var x = new new new f `abc${ 0 }def`.member("hello")(42) === true;
+
+
+
+//// [taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js]
+var f;
+var x = new new new f `abc${0}def`.member("hello")(42) === true;
diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types
new file mode 100644
index 00000000000..b8fb3377196
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types
@@ -0,0 +1,38 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts ===
+interface I {
+>I : I
+
+    (strs: string[], subs: number[]): I;
+>strs : string[]
+>subs : number[]
+>I : I
+
+    member: {
+>member : new (s: string) => new (n: number) => new () => boolean
+
+        new (s: string): {
+>s : string
+
+            new (n: number): {
+>n : number
+
+                new (): boolean;
+            }
+        }
+    };
+}
+var f: I;
+>f : I
+>I : I
+
+var x = new new new f `abc${ 0 }def`.member("hello")(42) === true;
+>x : boolean
+>new new new f `abc${ 0 }def`.member("hello")(42) === true : boolean
+>new new new f `abc${ 0 }def`.member("hello")(42) : any
+>new new f `abc${ 0 }def`.member("hello")(42) : any
+>new f `abc${ 0 }def`.member("hello") : any
+>f `abc${ 0 }def`.member : any
+>f : I
+>member : any
+
+
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAny.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAny.errors.txt
new file mode 100644
index 00000000000..f813e13e8b9
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAny.errors.txt
@@ -0,0 +1,64 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(3,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(5,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(7,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(9,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(11,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(13,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(15,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(17,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(19,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(19,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(21,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(21,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts (12 errors) ====
+    var f: any;
+    
+    f `abc`
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f.g.h `abc`
+    ~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f.g.h `abc${1}def${2}ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`.member
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`.member;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`["member"];
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`["member"];
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`["member"].someOtherTag `abc${1}def${2}ghi`;
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`["member"].someOtherTag `abc${1}def${2}ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f.thisIsNotATag(`abc`);
+    
+    f.thisIsNotATag(`abc${1}def${2}ghi`);
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAnyES6.js b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAnyES6.js
new file mode 100644
index 00000000000..997e1277442
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAnyES6.js
@@ -0,0 +1,40 @@
+//// [taggedTemplateStringsWithTagsTypedAsAnyES6.ts]
+var f: any;
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f.g.h `abc`
+
+f.g.h `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`["member"].someOtherTag `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].someOtherTag `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
+
+//// [taggedTemplateStringsWithTagsTypedAsAnyES6.js]
+var f;
+f `abc`;
+f `abc${1}def${2}ghi`;
+f.g.h `abc`;
+f.g.h `abc${1}def${2}ghi`;
+f `abc`.member;
+f `abc${1}def${2}ghi`.member;
+f `abc`["member"];
+f `abc${1}def${2}ghi`["member"];
+f `abc`["member"].someOtherTag `abc${1}def${2}ghi`;
+f `abc${1}def${2}ghi`["member"].someOtherTag `abc${1}def${2}ghi`;
+f.thisIsNotATag(`abc`);
+f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAnyES6.types b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAnyES6.types
new file mode 100644
index 00000000000..bb651fe1d25
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAnyES6.types
@@ -0,0 +1,66 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAnyES6.ts ===
+var f: any;
+>f : any
+
+f `abc`
+>f : any
+
+f `abc${1}def${2}ghi`;
+>f : any
+
+f.g.h `abc`
+>f.g.h : any
+>f.g : any
+>f : any
+>g : any
+>h : any
+
+f.g.h `abc${1}def${2}ghi`;
+>f.g.h : any
+>f.g : any
+>f : any
+>g : any
+>h : any
+
+f `abc`.member
+>f `abc`.member : any
+>f : any
+>member : any
+
+f `abc${1}def${2}ghi`.member;
+>f `abc${1}def${2}ghi`.member : any
+>f : any
+>member : any
+
+f `abc`["member"];
+>f `abc`["member"] : any
+>f : any
+
+f `abc${1}def${2}ghi`["member"];
+>f `abc${1}def${2}ghi`["member"] : any
+>f : any
+
+f `abc`["member"].someOtherTag `abc${1}def${2}ghi`;
+>f `abc`["member"].someOtherTag : any
+>f `abc`["member"] : any
+>f : any
+>someOtherTag : any
+
+f `abc${1}def${2}ghi`["member"].someOtherTag `abc${1}def${2}ghi`;
+>f `abc${1}def${2}ghi`["member"].someOtherTag : any
+>f `abc${1}def${2}ghi`["member"] : any
+>f : any
+>someOtherTag : any
+
+f.thisIsNotATag(`abc`);
+>f.thisIsNotATag(`abc`) : any
+>f.thisIsNotATag : any
+>f : any
+>thisIsNotATag : any
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
+>f.thisIsNotATag(`abc${1}def${2}ghi`) : any
+>f.thisIsNotATag : any
+>f : any
+>thisIsNotATag : any
+
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.errors.txt
new file mode 100644
index 00000000000..6a38ddc278a
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.errors.txt
@@ -0,0 +1,64 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(12,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(14,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(16,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(18,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(20,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(22,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(24,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(24,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(26,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(26,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts (10 errors) ====
+    interface I {
+        (stringParts: string[], ...rest: number[]): I;
+        g: I;
+        h: I;
+        member: I;
+        thisIsNotATag(x: string): void
+        [x: number]: I;
+    }
+    
+    var f: I;
+    
+    f `abc`
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`.member
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`.member;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`["member"];
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`["member"];
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc`[0].member `abc${1}def${2}ghi`;
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    f.thisIsNotATag(`abc`);
+    
+    f.thisIsNotATag(`abc${1}def${2}ghi`);
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.js b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.js
new file mode 100644
index 00000000000..9eefc46ec30
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.js
@@ -0,0 +1,45 @@
+//// [taggedTemplateStringsWithTypedTagsES6.ts]
+interface I {
+    (stringParts: string[], ...rest: number[]): I;
+    g: I;
+    h: I;
+    member: I;
+    thisIsNotATag(x: string): void
+    [x: number]: I;
+}
+
+var f: I;
+
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
+
+
+//// [taggedTemplateStringsWithTypedTagsES6.js]
+var f;
+f `abc`;
+f `abc${1}def${2}ghi`;
+f `abc`.member;
+f `abc${1}def${2}ghi`.member;
+f `abc`["member"];
+f `abc${1}def${2}ghi`["member"];
+f `abc`[0].member `abc${1}def${2}ghi`;
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+f.thisIsNotATag(`abc`);
+f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types
new file mode 100644
index 00000000000..9745320b397
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types
@@ -0,0 +1,82 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts ===
+interface I {
+>I : I
+
+    (stringParts: string[], ...rest: number[]): I;
+>stringParts : string[]
+>rest : number[]
+>I : I
+
+    g: I;
+>g : I
+>I : I
+
+    h: I;
+>h : I
+>I : I
+
+    member: I;
+>member : I
+>I : I
+
+    thisIsNotATag(x: string): void
+>thisIsNotATag : (x: string) => void
+>x : string
+
+    [x: number]: I;
+>x : number
+>I : I
+}
+
+var f: I;
+>f : I
+>I : I
+
+f `abc`
+>f : I
+
+f `abc${1}def${2}ghi`;
+>f : I
+
+f `abc`.member
+>f `abc`.member : any
+>f : I
+>member : any
+
+f `abc${1}def${2}ghi`.member;
+>f `abc${1}def${2}ghi`.member : any
+>f : I
+>member : any
+
+f `abc`["member"];
+>f `abc`["member"] : any
+>f : I
+
+f `abc${1}def${2}ghi`["member"];
+>f `abc${1}def${2}ghi`["member"] : any
+>f : I
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+>f `abc`[0].member : any
+>f `abc`[0] : any
+>f : I
+>member : any
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+>f `abc${1}def${2}ghi`["member"].member : any
+>f `abc${1}def${2}ghi`["member"] : any
+>f : I
+>member : any
+
+f.thisIsNotATag(`abc`);
+>f.thisIsNotATag(`abc`) : void
+>f.thisIsNotATag : (x: string) => void
+>f : I
+>thisIsNotATag : (x: string) => void
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
+>f.thisIsNotATag(`abc${1}def${2}ghi`) : void
+>f.thisIsNotATag : (x: string) => void
+>f : I
+>thisIsNotATag : (x: string) => void
+
diff --git a/tests/baselines/reference/templateStringInArray.js b/tests/baselines/reference/templateStringInArray.js
new file mode 100644
index 00000000000..97d0b1a636b
--- /dev/null
+++ b/tests/baselines/reference/templateStringInArray.js
@@ -0,0 +1,5 @@
+//// [templateStringInArray.ts]
+var x = [1, 2, `abc${ 123 }def`];
+
+//// [templateStringInArray.js]
+var x = [1, 2, ("abc" + 123 + "def")];
diff --git a/tests/baselines/reference/templateStringInArray.types b/tests/baselines/reference/templateStringInArray.types
new file mode 100644
index 00000000000..ef727f59b24
--- /dev/null
+++ b/tests/baselines/reference/templateStringInArray.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInArray.ts ===
+var x = [1, 2, `abc${ 123 }def`];
+>x : (string | number)[]
+>[1, 2, `abc${ 123 }def`] : (string | number)[]
+
diff --git a/tests/baselines/reference/templateStringInArrowFunction.js b/tests/baselines/reference/templateStringInArrowFunction.js
new file mode 100644
index 00000000000..4c4890633e1
--- /dev/null
+++ b/tests/baselines/reference/templateStringInArrowFunction.js
@@ -0,0 +1,5 @@
+//// [templateStringInArrowFunction.ts]
+var x = x => `abc${ x }def`;
+
+//// [templateStringInArrowFunction.js]
+var x = function (x) { return ("abc" + x + "def"); };
diff --git a/tests/baselines/reference/templateStringInArrowFunction.types b/tests/baselines/reference/templateStringInArrowFunction.types
new file mode 100644
index 00000000000..e17f4d6d2ea
--- /dev/null
+++ b/tests/baselines/reference/templateStringInArrowFunction.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringInArrowFunction.ts ===
+var x = x => `abc${ x }def`;
+>x : (x: any) => string
+>x => `abc${ x }def` : (x: any) => string
+>x : any
+>x : unknown
+
diff --git a/tests/baselines/reference/templateStringInArrowFunctionES6.js b/tests/baselines/reference/templateStringInArrowFunctionES6.js
new file mode 100644
index 00000000000..633b96e9da4
--- /dev/null
+++ b/tests/baselines/reference/templateStringInArrowFunctionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInArrowFunctionES6.ts]
+var x = x => `abc${ x }def`;
+
+//// [templateStringInArrowFunctionES6.js]
+var x = function (x) { return `abc${x}def`; };
diff --git a/tests/baselines/reference/templateStringInArrowFunctionES6.types b/tests/baselines/reference/templateStringInArrowFunctionES6.types
new file mode 100644
index 00000000000..38fca60e647
--- /dev/null
+++ b/tests/baselines/reference/templateStringInArrowFunctionES6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringInArrowFunctionES6.ts ===
+var x = x => `abc${ x }def`;
+>x : (x: any) => string
+>x => `abc${ x }def` : (x: any) => string
+>x : any
+>x : unknown
+
diff --git a/tests/baselines/reference/templateStringInBinaryAddition.js b/tests/baselines/reference/templateStringInBinaryAddition.js
new file mode 100644
index 00000000000..0e1f728005c
--- /dev/null
+++ b/tests/baselines/reference/templateStringInBinaryAddition.js
@@ -0,0 +1,5 @@
+//// [templateStringInBinaryAddition.ts]
+var x = 10 + `abc${ 10 }def`;
+
+//// [templateStringInBinaryAddition.js]
+var x = 10 + ("abc" + 10 + "def");
diff --git a/tests/baselines/reference/templateStringInBinaryAddition.types b/tests/baselines/reference/templateStringInBinaryAddition.types
new file mode 100644
index 00000000000..f722ff696f4
--- /dev/null
+++ b/tests/baselines/reference/templateStringInBinaryAddition.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInBinaryAddition.ts ===
+var x = 10 + `abc${ 10 }def`;
+>x : string
+>10 + `abc${ 10 }def` : string
+
diff --git a/tests/baselines/reference/templateStringInBinaryAdditionES6.js b/tests/baselines/reference/templateStringInBinaryAdditionES6.js
new file mode 100644
index 00000000000..7a40d4cc54f
--- /dev/null
+++ b/tests/baselines/reference/templateStringInBinaryAdditionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInBinaryAdditionES6.ts]
+var x = 10 + `abc${ 10 }def`;
+
+//// [templateStringInBinaryAdditionES6.js]
+var x = 10 + `abc${10}def`;
diff --git a/tests/baselines/reference/templateStringInBinaryAdditionES6.types b/tests/baselines/reference/templateStringInBinaryAdditionES6.types
new file mode 100644
index 00000000000..b421d7dc70e
--- /dev/null
+++ b/tests/baselines/reference/templateStringInBinaryAdditionES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInBinaryAdditionES6.ts ===
+var x = 10 + `abc${ 10 }def`;
+>x : string
+>10 + `abc${ 10 }def` : string
+
diff --git a/tests/baselines/reference/templateStringInConditional.js b/tests/baselines/reference/templateStringInConditional.js
new file mode 100644
index 00000000000..8ffcf24e5f4
--- /dev/null
+++ b/tests/baselines/reference/templateStringInConditional.js
@@ -0,0 +1,5 @@
+//// [templateStringInConditional.ts]
+var x = `abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def`;
+
+//// [templateStringInConditional.js]
+var x = "abc" + " " + "def" ? "abc" + " " + "def" : "abc" + " " + "def";
diff --git a/tests/baselines/reference/templateStringInConditional.types b/tests/baselines/reference/templateStringInConditional.types
new file mode 100644
index 00000000000..b4ff36b3891
--- /dev/null
+++ b/tests/baselines/reference/templateStringInConditional.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInConditional.ts ===
+var x = `abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def`;
+>x : string
+>`abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def` : string
+
diff --git a/tests/baselines/reference/templateStringInConditionalES6.js b/tests/baselines/reference/templateStringInConditionalES6.js
new file mode 100644
index 00000000000..d212b5c7717
--- /dev/null
+++ b/tests/baselines/reference/templateStringInConditionalES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInConditionalES6.ts]
+var x = `abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def`;
+
+//// [templateStringInConditionalES6.js]
+var x = `abc${" "}def` ? `abc${" "}def` : `abc${" "}def`;
diff --git a/tests/baselines/reference/templateStringInConditionalES6.types b/tests/baselines/reference/templateStringInConditionalES6.types
new file mode 100644
index 00000000000..c211ced2583
--- /dev/null
+++ b/tests/baselines/reference/templateStringInConditionalES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInConditionalES6.ts ===
+var x = `abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def`;
+>x : string
+>`abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def` : string
+
diff --git a/tests/baselines/reference/templateStringInDeleteExpression.js b/tests/baselines/reference/templateStringInDeleteExpression.js
new file mode 100644
index 00000000000..e8da2e2ba32
--- /dev/null
+++ b/tests/baselines/reference/templateStringInDeleteExpression.js
@@ -0,0 +1,5 @@
+//// [templateStringInDeleteExpression.ts]
+delete `abc${0}abc`;
+
+//// [templateStringInDeleteExpression.js]
+delete ("abc" + 0 + "abc");
diff --git a/tests/baselines/reference/templateStringInDeleteExpression.types b/tests/baselines/reference/templateStringInDeleteExpression.types
new file mode 100644
index 00000000000..88693e5a9bb
--- /dev/null
+++ b/tests/baselines/reference/templateStringInDeleteExpression.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/templates/templateStringInDeleteExpression.ts ===
+delete `abc${0}abc`;
+>delete `abc${0}abc` : boolean
+
diff --git a/tests/baselines/reference/templateStringInDeleteExpressionES6.js b/tests/baselines/reference/templateStringInDeleteExpressionES6.js
new file mode 100644
index 00000000000..19f5d51b021
--- /dev/null
+++ b/tests/baselines/reference/templateStringInDeleteExpressionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInDeleteExpressionES6.ts]
+delete `abc${0}abc`;
+
+//// [templateStringInDeleteExpressionES6.js]
+delete `abc${0}abc`;
diff --git a/tests/baselines/reference/templateStringInDeleteExpressionES6.types b/tests/baselines/reference/templateStringInDeleteExpressionES6.types
new file mode 100644
index 00000000000..d67d4d8c703
--- /dev/null
+++ b/tests/baselines/reference/templateStringInDeleteExpressionES6.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/templates/templateStringInDeleteExpressionES6.ts ===
+delete `abc${0}abc`;
+>delete `abc${0}abc` : boolean
+
diff --git a/tests/baselines/reference/templateStringInDivision.errors.txt b/tests/baselines/reference/templateStringInDivision.errors.txt
new file mode 100644
index 00000000000..32cc4830399
--- /dev/null
+++ b/tests/baselines/reference/templateStringInDivision.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInDivision.ts(1,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInDivision.ts (1 errors) ====
+    var x = `abc${ 1 }def` / 1;
+            ~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInDivision.js b/tests/baselines/reference/templateStringInDivision.js
new file mode 100644
index 00000000000..d624d73f6bb
--- /dev/null
+++ b/tests/baselines/reference/templateStringInDivision.js
@@ -0,0 +1,5 @@
+//// [templateStringInDivision.ts]
+var x = `abc${ 1 }def` / 1;
+
+//// [templateStringInDivision.js]
+var x = ("abc" + 1 + "def") / 1;
diff --git a/tests/baselines/reference/templateStringInEqualityChecks.js b/tests/baselines/reference/templateStringInEqualityChecks.js
new file mode 100644
index 00000000000..54f5fa610c2
--- /dev/null
+++ b/tests/baselines/reference/templateStringInEqualityChecks.js
@@ -0,0 +1,8 @@
+//// [templateStringInEqualityChecks.ts]
+var x = `abc${0}abc` === `abc` ||
+        `abc` !== `abc${0}abc` &&
+        `abc${0}abc` == "abc0abc" &&
+        "abc0abc" !== `abc${0}abc`;
+
+//// [templateStringInEqualityChecks.js]
+var x = "abc" + 0 + "abc" === "abc" || "abc" !== "abc" + 0 + "abc" && "abc" + 0 + "abc" == "abc0abc" && "abc0abc" !== "abc" + 0 + "abc";
diff --git a/tests/baselines/reference/templateStringInEqualityChecks.types b/tests/baselines/reference/templateStringInEqualityChecks.types
new file mode 100644
index 00000000000..a942d4bce98
--- /dev/null
+++ b/tests/baselines/reference/templateStringInEqualityChecks.types
@@ -0,0 +1,17 @@
+=== tests/cases/conformance/es6/templates/templateStringInEqualityChecks.ts ===
+var x = `abc${0}abc` === `abc` ||
+>x : boolean
+>`abc${0}abc` === `abc` ||        `abc` !== `abc${0}abc` &&        `abc${0}abc` == "abc0abc" &&        "abc0abc" !== `abc${0}abc` : boolean
+>`abc${0}abc` === `abc` : boolean
+
+        `abc` !== `abc${0}abc` &&
+>`abc` !== `abc${0}abc` &&        `abc${0}abc` == "abc0abc" &&        "abc0abc" !== `abc${0}abc` : boolean
+>`abc` !== `abc${0}abc` &&        `abc${0}abc` == "abc0abc" : boolean
+>`abc` !== `abc${0}abc` : boolean
+
+        `abc${0}abc` == "abc0abc" &&
+>`abc${0}abc` == "abc0abc" : boolean
+
+        "abc0abc" !== `abc${0}abc`;
+>"abc0abc" !== `abc${0}abc` : boolean
+
diff --git a/tests/baselines/reference/templateStringInEqualityChecksES6.js b/tests/baselines/reference/templateStringInEqualityChecksES6.js
new file mode 100644
index 00000000000..317db1ab366
--- /dev/null
+++ b/tests/baselines/reference/templateStringInEqualityChecksES6.js
@@ -0,0 +1,8 @@
+//// [templateStringInEqualityChecksES6.ts]
+var x = `abc${0}abc` === `abc` ||
+        `abc` !== `abc${0}abc` &&
+        `abc${0}abc` == "abc0abc" &&
+        "abc0abc" !== `abc${0}abc`;
+
+//// [templateStringInEqualityChecksES6.js]
+var x = `abc${0}abc` === `abc` || `abc` !== `abc${0}abc` && `abc${0}abc` == "abc0abc" && "abc0abc" !== `abc${0}abc`;
diff --git a/tests/baselines/reference/templateStringInEqualityChecksES6.types b/tests/baselines/reference/templateStringInEqualityChecksES6.types
new file mode 100644
index 00000000000..ffe300ccd38
--- /dev/null
+++ b/tests/baselines/reference/templateStringInEqualityChecksES6.types
@@ -0,0 +1,17 @@
+=== tests/cases/conformance/es6/templates/templateStringInEqualityChecksES6.ts ===
+var x = `abc${0}abc` === `abc` ||
+>x : boolean
+>`abc${0}abc` === `abc` ||        `abc` !== `abc${0}abc` &&        `abc${0}abc` == "abc0abc" &&        "abc0abc" !== `abc${0}abc` : boolean
+>`abc${0}abc` === `abc` : boolean
+
+        `abc` !== `abc${0}abc` &&
+>`abc` !== `abc${0}abc` &&        `abc${0}abc` == "abc0abc" &&        "abc0abc" !== `abc${0}abc` : boolean
+>`abc` !== `abc${0}abc` &&        `abc${0}abc` == "abc0abc" : boolean
+>`abc` !== `abc${0}abc` : boolean
+
+        `abc${0}abc` == "abc0abc" &&
+>`abc${0}abc` == "abc0abc" : boolean
+
+        "abc0abc" !== `abc${0}abc`;
+>"abc0abc" !== `abc${0}abc` : boolean
+
diff --git a/tests/baselines/reference/templateStringInFunctionExpression.js b/tests/baselines/reference/templateStringInFunctionExpression.js
new file mode 100644
index 00000000000..9711b2edc3a
--- /dev/null
+++ b/tests/baselines/reference/templateStringInFunctionExpression.js
@@ -0,0 +1,11 @@
+//// [templateStringInFunctionExpression.ts]
+var x = function y() {
+    `abc${ 0 }def`
+    return `abc${ 0 }def`;
+};
+
+//// [templateStringInFunctionExpression.js]
+var x = function y() {
+    "abc" + 0 + "def";
+    return "abc" + 0 + "def";
+};
diff --git a/tests/baselines/reference/templateStringInFunctionExpression.types b/tests/baselines/reference/templateStringInFunctionExpression.types
new file mode 100644
index 00000000000..1ec389488ec
--- /dev/null
+++ b/tests/baselines/reference/templateStringInFunctionExpression.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/templates/templateStringInFunctionExpression.ts ===
+var x = function y() {
+>x : () => string
+>function y() {    `abc${ 0 }def`    return `abc${ 0 }def`;} : () => string
+>y : () => string
+
+    `abc${ 0 }def`
+    return `abc${ 0 }def`;
+};
diff --git a/tests/baselines/reference/templateStringInFunctionExpressionES6.js b/tests/baselines/reference/templateStringInFunctionExpressionES6.js
new file mode 100644
index 00000000000..e7cffe1471b
--- /dev/null
+++ b/tests/baselines/reference/templateStringInFunctionExpressionES6.js
@@ -0,0 +1,11 @@
+//// [templateStringInFunctionExpressionES6.ts]
+var x = function y() {
+    `abc${ 0 }def`
+    return `abc${ 0 }def`;
+};
+
+//// [templateStringInFunctionExpressionES6.js]
+var x = function y() {
+    `abc${0}def`;
+    return `abc${0}def`;
+};
diff --git a/tests/baselines/reference/templateStringInFunctionExpressionES6.types b/tests/baselines/reference/templateStringInFunctionExpressionES6.types
new file mode 100644
index 00000000000..a31558fbe37
--- /dev/null
+++ b/tests/baselines/reference/templateStringInFunctionExpressionES6.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/templates/templateStringInFunctionExpressionES6.ts ===
+var x = function y() {
+>x : () => string
+>function y() {    `abc${ 0 }def`    return `abc${ 0 }def`;} : () => string
+>y : () => string
+
+    `abc${ 0 }def`
+    return `abc${ 0 }def`;
+};
diff --git a/tests/baselines/reference/templateStringInFunctionParameterType.errors.txt b/tests/baselines/reference/templateStringInFunctionParameterType.errors.txt
new file mode 100644
index 00000000000..e0c35e3f19f
--- /dev/null
+++ b/tests/baselines/reference/templateStringInFunctionParameterType.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts(1,12): error TS1138: Parameter declaration expected.
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts(1,19): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts(1,1): error TS2394: Overload signature is not compatible with function implementation.
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts(1,10): error TS2391: Function implementation is missing or not immediately following the declaration.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts (4 errors) ====
+    function f(`hello`);
+               ~~~~~~~
+!!! error TS1138: Parameter declaration expected.
+                      ~
+!!! error TS1005: ';' expected.
+    ~~~~~~~~~~~
+!!! error TS2394: Overload signature is not compatible with function implementation.
+             ~
+!!! error TS2391: Function implementation is missing or not immediately following the declaration.
+    function f(x: string);
+    function f(x: string) {
+        return x;
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInFunctionParameterTypeES6.errors.txt b/tests/baselines/reference/templateStringInFunctionParameterTypeES6.errors.txt
new file mode 100644
index 00000000000..948c9ccc6cd
--- /dev/null
+++ b/tests/baselines/reference/templateStringInFunctionParameterTypeES6.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts(1,12): error TS1138: Parameter declaration expected.
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts(1,19): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts(1,1): error TS2394: Overload signature is not compatible with function implementation.
+tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts(1,10): error TS2391: Function implementation is missing or not immediately following the declaration.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts (4 errors) ====
+    function f(`hello`);
+               ~~~~~~~
+!!! error TS1138: Parameter declaration expected.
+                      ~
+!!! error TS1005: ';' expected.
+    ~~~~~~~~~~~
+!!! error TS2394: Overload signature is not compatible with function implementation.
+             ~
+!!! error TS2391: Function implementation is missing or not immediately following the declaration.
+    function f(x: string);
+    function f(x: string) {
+        return x;
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInInOperator.js b/tests/baselines/reference/templateStringInInOperator.js
new file mode 100644
index 00000000000..c496e335dd4
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInOperator.js
@@ -0,0 +1,5 @@
+//// [templateStringInInOperator.ts]
+var x = `${ "hi" }` in { hi: 10, hello: 20};
+
+//// [templateStringInInOperator.js]
+var x = "" + "hi" in { hi: 10, hello: 20 };
diff --git a/tests/baselines/reference/templateStringInInOperator.types b/tests/baselines/reference/templateStringInInOperator.types
new file mode 100644
index 00000000000..da35bdc499c
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInOperator.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringInInOperator.ts ===
+var x = `${ "hi" }` in { hi: 10, hello: 20};
+>x : boolean
+>`${ "hi" }` in { hi: 10, hello: 20} : boolean
+>{ hi: 10, hello: 20} : { hi: number; hello: number; }
+>hi : number
+>hello : number
+
diff --git a/tests/baselines/reference/templateStringInInOperatorES6.js b/tests/baselines/reference/templateStringInInOperatorES6.js
new file mode 100644
index 00000000000..bd4daef3b6d
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInOperatorES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInInOperatorES6.ts]
+var x = `${ "hi" }` in { hi: 10, hello: 20};
+
+//// [templateStringInInOperatorES6.js]
+var x = `${"hi"}` in { hi: 10, hello: 20 };
diff --git a/tests/baselines/reference/templateStringInInOperatorES6.types b/tests/baselines/reference/templateStringInInOperatorES6.types
new file mode 100644
index 00000000000..7af0d7a2f48
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInOperatorES6.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringInInOperatorES6.ts ===
+var x = `${ "hi" }` in { hi: 10, hello: 20};
+>x : boolean
+>`${ "hi" }` in { hi: 10, hello: 20} : boolean
+>{ hi: 10, hello: 20} : { hi: number; hello: number; }
+>hi : number
+>hello : number
+
diff --git a/tests/baselines/reference/templateStringInIndexExpression.js b/tests/baselines/reference/templateStringInIndexExpression.js
new file mode 100644
index 00000000000..680cfb49f47
--- /dev/null
+++ b/tests/baselines/reference/templateStringInIndexExpression.js
@@ -0,0 +1,5 @@
+//// [templateStringInIndexExpression.ts]
+`abc${0}abc`[`0`];
+
+//// [templateStringInIndexExpression.js]
+("abc" + 0 + "abc")["0"];
diff --git a/tests/baselines/reference/templateStringInIndexExpression.types b/tests/baselines/reference/templateStringInIndexExpression.types
new file mode 100644
index 00000000000..a0270b850ab
--- /dev/null
+++ b/tests/baselines/reference/templateStringInIndexExpression.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/templates/templateStringInIndexExpression.ts ===
+`abc${0}abc`[`0`];
+>`abc${0}abc`[`0`] : any
+
diff --git a/tests/baselines/reference/templateStringInIndexExpressionES6.js b/tests/baselines/reference/templateStringInIndexExpressionES6.js
new file mode 100644
index 00000000000..c1c87211a05
--- /dev/null
+++ b/tests/baselines/reference/templateStringInIndexExpressionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInIndexExpressionES6.ts]
+`abc${0}abc`[`0`];
+
+//// [templateStringInIndexExpressionES6.js]
+`abc${0}abc`[`0`];
diff --git a/tests/baselines/reference/templateStringInIndexExpressionES6.types b/tests/baselines/reference/templateStringInIndexExpressionES6.types
new file mode 100644
index 00000000000..aceb22da529
--- /dev/null
+++ b/tests/baselines/reference/templateStringInIndexExpressionES6.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/templates/templateStringInIndexExpressionES6.ts ===
+`abc${0}abc`[`0`];
+>`abc${0}abc`[`0`] : any
+
diff --git a/tests/baselines/reference/templateStringInInstanceOf.errors.txt b/tests/baselines/reference/templateStringInInstanceOf.errors.txt
new file mode 100644
index 00000000000..04d2584712b
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInstanceOf.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInInstanceOf.ts(1,9): error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInInstanceOf.ts (1 errors) ====
+    var x = `abc${ 0 }def` instanceof String;
+            ~~~~~~~~~~~~~~
+!!! error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInInstanceOf.js b/tests/baselines/reference/templateStringInInstanceOf.js
new file mode 100644
index 00000000000..ccf022cc703
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInstanceOf.js
@@ -0,0 +1,5 @@
+//// [templateStringInInstanceOf.ts]
+var x = `abc${ 0 }def` instanceof String;
+
+//// [templateStringInInstanceOf.js]
+var x = "abc" + 0 + "def" instanceof String;
diff --git a/tests/baselines/reference/templateStringInInstanceOfES6.errors.txt b/tests/baselines/reference/templateStringInInstanceOfES6.errors.txt
new file mode 100644
index 00000000000..0fc8c81ab92
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInstanceOfES6.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInInstanceOfES6.ts(1,9): error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInInstanceOfES6.ts (1 errors) ====
+    var x = `abc${ 0 }def` instanceof String;
+            ~~~~~~~~~~~~~~
+!!! error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInInstanceOfES6.js b/tests/baselines/reference/templateStringInInstanceOfES6.js
new file mode 100644
index 00000000000..793c183d137
--- /dev/null
+++ b/tests/baselines/reference/templateStringInInstanceOfES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInInstanceOfES6.ts]
+var x = `abc${ 0 }def` instanceof String;
+
+//// [templateStringInInstanceOfES6.js]
+var x = `abc${0}def` instanceof String;
diff --git a/tests/baselines/reference/templateStringInModuleName.errors.txt b/tests/baselines/reference/templateStringInModuleName.errors.txt
new file mode 100644
index 00000000000..8b5e4eb8e14
--- /dev/null
+++ b/tests/baselines/reference/templateStringInModuleName.errors.txt
@@ -0,0 +1,38 @@
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(1,9): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(1,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(1,21): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(4,9): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(4,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(4,24): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(1,1): error TS2304: Cannot find name 'declare'.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(1,9): error TS2304: Cannot find name 'module'.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(4,1): error TS2304: Cannot find name 'declare'.
+tests/cases/conformance/es6/templates/templateStringInModuleName.ts(4,9): error TS2304: Cannot find name 'module'.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInModuleName.ts (10 errors) ====
+    declare module `M1` {
+            ~~~~~~
+!!! error TS1005: ';' expected.
+            ~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                        ~
+!!! error TS1005: ';' expected.
+    ~~~~~~~
+!!! error TS2304: Cannot find name 'declare'.
+            ~~~~~~
+!!! error TS2304: Cannot find name 'module'.
+    }
+    
+    declare module `M${2}` {
+            ~~~~~~
+!!! error TS1005: ';' expected.
+            ~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                           ~
+!!! error TS1005: ';' expected.
+    ~~~~~~~
+!!! error TS2304: Cannot find name 'declare'.
+            ~~~~~~
+!!! error TS2304: Cannot find name 'module'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInModuleNameES6.errors.txt b/tests/baselines/reference/templateStringInModuleNameES6.errors.txt
new file mode 100644
index 00000000000..228fd32357c
--- /dev/null
+++ b/tests/baselines/reference/templateStringInModuleNameES6.errors.txt
@@ -0,0 +1,32 @@
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(1,9): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(1,21): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(4,9): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(4,24): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(1,1): error TS2304: Cannot find name 'declare'.
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(1,9): error TS2304: Cannot find name 'module'.
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(4,1): error TS2304: Cannot find name 'declare'.
+tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts(4,9): error TS2304: Cannot find name 'module'.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts (8 errors) ====
+    declare module `M1` {
+            ~~~~~~
+!!! error TS1005: ';' expected.
+                        ~
+!!! error TS1005: ';' expected.
+    ~~~~~~~
+!!! error TS2304: Cannot find name 'declare'.
+            ~~~~~~
+!!! error TS2304: Cannot find name 'module'.
+    }
+    
+    declare module `M${2}` {
+            ~~~~~~
+!!! error TS1005: ';' expected.
+                           ~
+!!! error TS1005: ';' expected.
+    ~~~~~~~
+!!! error TS2304: Cannot find name 'declare'.
+            ~~~~~~
+!!! error TS2304: Cannot find name 'module'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInModulo.errors.txt b/tests/baselines/reference/templateStringInModulo.errors.txt
new file mode 100644
index 00000000000..f9f0b0257d6
--- /dev/null
+++ b/tests/baselines/reference/templateStringInModulo.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInModulo.ts(1,13): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInModulo.ts (1 errors) ====
+    var x = 1 % `abc${ 1 }def`;
+                ~~~~~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInModulo.js b/tests/baselines/reference/templateStringInModulo.js
new file mode 100644
index 00000000000..65d5ec7eaab
--- /dev/null
+++ b/tests/baselines/reference/templateStringInModulo.js
@@ -0,0 +1,5 @@
+//// [templateStringInModulo.ts]
+var x = 1 % `abc${ 1 }def`;
+
+//// [templateStringInModulo.js]
+var x = 1 % ("abc" + 1 + "def");
diff --git a/tests/baselines/reference/templateStringInModuloES6.errors.txt b/tests/baselines/reference/templateStringInModuloES6.errors.txt
new file mode 100644
index 00000000000..db410876b91
--- /dev/null
+++ b/tests/baselines/reference/templateStringInModuloES6.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInModuloES6.ts(1,13): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInModuloES6.ts (1 errors) ====
+    var x = 1 % `abc${ 1 }def`;
+                ~~~~~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInModuloES6.js b/tests/baselines/reference/templateStringInModuloES6.js
new file mode 100644
index 00000000000..2fae209b85f
--- /dev/null
+++ b/tests/baselines/reference/templateStringInModuloES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInModuloES6.ts]
+var x = 1 % `abc${ 1 }def`;
+
+//// [templateStringInModuloES6.js]
+var x = 1 % `abc${1}def`;
diff --git a/tests/baselines/reference/templateStringInMultiplication.errors.txt b/tests/baselines/reference/templateStringInMultiplication.errors.txt
new file mode 100644
index 00000000000..11a4ea9985e
--- /dev/null
+++ b/tests/baselines/reference/templateStringInMultiplication.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInMultiplication.ts(1,13): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInMultiplication.ts (1 errors) ====
+    var x = 1 * `abc${ 1 }def`;
+                ~~~~~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInMultiplication.js b/tests/baselines/reference/templateStringInMultiplication.js
new file mode 100644
index 00000000000..e48db6e1715
--- /dev/null
+++ b/tests/baselines/reference/templateStringInMultiplication.js
@@ -0,0 +1,5 @@
+//// [templateStringInMultiplication.ts]
+var x = 1 * `abc${ 1 }def`;
+
+//// [templateStringInMultiplication.js]
+var x = 1 * ("abc" + 1 + "def");
diff --git a/tests/baselines/reference/templateStringInMultiplicationES6.errors.txt b/tests/baselines/reference/templateStringInMultiplicationES6.errors.txt
new file mode 100644
index 00000000000..ee27091778f
--- /dev/null
+++ b/tests/baselines/reference/templateStringInMultiplicationES6.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInMultiplicationES6.ts(1,13): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInMultiplicationES6.ts (1 errors) ====
+    var x = 1 * `abc${ 1 }def`;
+                ~~~~~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInMultiplicationES6.js b/tests/baselines/reference/templateStringInMultiplicationES6.js
new file mode 100644
index 00000000000..f890e900301
--- /dev/null
+++ b/tests/baselines/reference/templateStringInMultiplicationES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInMultiplicationES6.ts]
+var x = 1 * `abc${ 1 }def`;
+
+//// [templateStringInMultiplicationES6.js]
+var x = 1 * `abc${1}def`;
diff --git a/tests/baselines/reference/templateStringInNewOperator.errors.txt b/tests/baselines/reference/templateStringInNewOperator.errors.txt
new file mode 100644
index 00000000000..eed7415e5d2
--- /dev/null
+++ b/tests/baselines/reference/templateStringInNewOperator.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInNewOperator.ts(1,9): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInNewOperator.ts (1 errors) ====
+    var x = new `abc${ 1 }def`;
+            ~~~~~~~~~~~~~~~~~~
+!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInNewOperator.js b/tests/baselines/reference/templateStringInNewOperator.js
new file mode 100644
index 00000000000..8d76d59f7ee
--- /dev/null
+++ b/tests/baselines/reference/templateStringInNewOperator.js
@@ -0,0 +1,5 @@
+//// [templateStringInNewOperator.ts]
+var x = new `abc${ 1 }def`;
+
+//// [templateStringInNewOperator.js]
+var x = new ("abc" + 1 + "def");
diff --git a/tests/baselines/reference/templateStringInNewOperatorES6.errors.txt b/tests/baselines/reference/templateStringInNewOperatorES6.errors.txt
new file mode 100644
index 00000000000..f4363d9ff20
--- /dev/null
+++ b/tests/baselines/reference/templateStringInNewOperatorES6.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringInNewOperatorES6.ts(1,9): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInNewOperatorES6.ts (1 errors) ====
+    var x = new `abc${ 1 }def`;
+            ~~~~~~~~~~~~~~~~~~
+!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInNewOperatorES6.js b/tests/baselines/reference/templateStringInNewOperatorES6.js
new file mode 100644
index 00000000000..066978f736b
--- /dev/null
+++ b/tests/baselines/reference/templateStringInNewOperatorES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInNewOperatorES6.ts]
+var x = new `abc${ 1 }def`;
+
+//// [templateStringInNewOperatorES6.js]
+var x = new `abc${1}def`;
diff --git a/tests/baselines/reference/templateStringInObjectLiteral.errors.txt b/tests/baselines/reference/templateStringInObjectLiteral.errors.txt
new file mode 100644
index 00000000000..8604338d678
--- /dev/null
+++ b/tests/baselines/reference/templateStringInObjectLiteral.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(1,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(3,5): error TS1136: Property assignment expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(3,8): error TS1005: ',' expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(3,10): error TS1134: Variable declaration expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(4,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts (5 errors) ====
+    var x = {
+            ~
+        a: `abc${ 123 }def`,
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+        `b`: 321
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+        ~~~
+!!! error TS1136: Property assignment expected.
+           ~
+!!! error TS1005: ',' expected.
+             ~~~
+!!! error TS1134: Variable declaration expected.
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInObjectLiteralES6.errors.txt b/tests/baselines/reference/templateStringInObjectLiteralES6.errors.txt
new file mode 100644
index 00000000000..ae21ecd4739
--- /dev/null
+++ b/tests/baselines/reference/templateStringInObjectLiteralES6.errors.txt
@@ -0,0 +1,19 @@
+tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(3,5): error TS1136: Property assignment expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(3,8): error TS1005: ',' expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(3,10): error TS1134: Variable declaration expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(4,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts (4 errors) ====
+    var x = {
+        a: `abc${ 123 }def`,
+        `b`: 321
+        ~~~
+!!! error TS1136: Property assignment expected.
+           ~
+!!! error TS1005: ',' expected.
+             ~~~
+!!! error TS1134: Variable declaration expected.
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInParentheses.js b/tests/baselines/reference/templateStringInParentheses.js
new file mode 100644
index 00000000000..6c5c678bf4e
--- /dev/null
+++ b/tests/baselines/reference/templateStringInParentheses.js
@@ -0,0 +1,5 @@
+//// [templateStringInParentheses.ts]
+var x = (`abc${0}abc`);
+
+//// [templateStringInParentheses.js]
+var x = ("abc" + 0 + "abc");
diff --git a/tests/baselines/reference/templateStringInParentheses.types b/tests/baselines/reference/templateStringInParentheses.types
new file mode 100644
index 00000000000..7e597dc0108
--- /dev/null
+++ b/tests/baselines/reference/templateStringInParentheses.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInParentheses.ts ===
+var x = (`abc${0}abc`);
+>x : string
+>(`abc${0}abc`) : string
+
diff --git a/tests/baselines/reference/templateStringInParenthesesES6.js b/tests/baselines/reference/templateStringInParenthesesES6.js
new file mode 100644
index 00000000000..0776ea594d2
--- /dev/null
+++ b/tests/baselines/reference/templateStringInParenthesesES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInParenthesesES6.ts]
+var x = (`abc${0}abc`);
+
+//// [templateStringInParenthesesES6.js]
+var x = (`abc${0}abc`);
diff --git a/tests/baselines/reference/templateStringInParenthesesES6.types b/tests/baselines/reference/templateStringInParenthesesES6.types
new file mode 100644
index 00000000000..3afb3530dee
--- /dev/null
+++ b/tests/baselines/reference/templateStringInParenthesesES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInParenthesesES6.ts ===
+var x = (`abc${0}abc`);
+>x : string
+>(`abc${0}abc`) : string
+
diff --git a/tests/baselines/reference/templateStringInPropertyAssignment.js b/tests/baselines/reference/templateStringInPropertyAssignment.js
new file mode 100644
index 00000000000..99fb24712c0
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyAssignment.js
@@ -0,0 +1,9 @@
+//// [templateStringInPropertyAssignment.ts]
+var x = {
+    a: `abc${ 123 }def${ 456 }ghi`
+}
+
+//// [templateStringInPropertyAssignment.js]
+var x = {
+    a: "abc" + 123 + "def" + 456 + "ghi"
+};
diff --git a/tests/baselines/reference/templateStringInPropertyAssignment.types b/tests/baselines/reference/templateStringInPropertyAssignment.types
new file mode 100644
index 00000000000..ff5ecb410db
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyAssignment.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringInPropertyAssignment.ts ===
+var x = {
+>x : { a: string; }
+>{    a: `abc${ 123 }def${ 456 }ghi`} : { a: string; }
+
+    a: `abc${ 123 }def${ 456 }ghi`
+>a : string
+}
diff --git a/tests/baselines/reference/templateStringInPropertyAssignmentES6.js b/tests/baselines/reference/templateStringInPropertyAssignmentES6.js
new file mode 100644
index 00000000000..fc35c0a831a
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyAssignmentES6.js
@@ -0,0 +1,9 @@
+//// [templateStringInPropertyAssignmentES6.ts]
+var x = {
+    a: `abc${ 123 }def${ 456 }ghi`
+}
+
+//// [templateStringInPropertyAssignmentES6.js]
+var x = {
+    a: `abc${123}def${456}ghi`
+};
diff --git a/tests/baselines/reference/templateStringInPropertyAssignmentES6.types b/tests/baselines/reference/templateStringInPropertyAssignmentES6.types
new file mode 100644
index 00000000000..fafc9f12a48
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyAssignmentES6.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringInPropertyAssignmentES6.ts ===
+var x = {
+>x : { a: string; }
+>{    a: `abc${ 123 }def${ 456 }ghi`} : { a: string; }
+
+    a: `abc${ 123 }def${ 456 }ghi`
+>a : string
+}
diff --git a/tests/baselines/reference/templateStringInPropertyName1.errors.txt b/tests/baselines/reference/templateStringInPropertyName1.errors.txt
new file mode 100644
index 00000000000..0e7dc998046
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyName1.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(1,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(2,5): error TS1136: Property assignment expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(2,8): error TS1005: ',' expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(2,10): error TS1134: Variable declaration expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(3,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts (5 errors) ====
+    var x = {
+            ~
+        `a`: 321
+    ~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+        ~~~
+!!! error TS1136: Property assignment expected.
+           ~
+!!! error TS1005: ',' expected.
+             ~~~
+!!! error TS1134: Variable declaration expected.
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInPropertyName2.errors.txt b/tests/baselines/reference/templateStringInPropertyName2.errors.txt
new file mode 100644
index 00000000000..a20d09f401f
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyName2.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(1,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(2,5): error TS1136: Property assignment expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(2,32): error TS1005: ',' expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(2,34): error TS1134: Variable declaration expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(3,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts (5 errors) ====
+    var x = {
+            ~
+        `abc${ 123 }def${ 456 }ghi`: 321
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+        ~~~~~~
+!!! error TS1136: Property assignment expected.
+                                   ~
+!!! error TS1005: ',' expected.
+                                     ~~~
+!!! error TS1134: Variable declaration expected.
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInPropertyNameES6_1.errors.txt b/tests/baselines/reference/templateStringInPropertyNameES6_1.errors.txt
new file mode 100644
index 00000000000..b45de2faaa1
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyNameES6_1.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(2,5): error TS1136: Property assignment expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(2,8): error TS1005: ',' expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(2,10): error TS1134: Variable declaration expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(3,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts (4 errors) ====
+    var x = {
+        `a`: 321
+        ~~~
+!!! error TS1136: Property assignment expected.
+           ~
+!!! error TS1005: ',' expected.
+             ~~~
+!!! error TS1134: Variable declaration expected.
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInPropertyNameES6_2.errors.txt b/tests/baselines/reference/templateStringInPropertyNameES6_2.errors.txt
new file mode 100644
index 00000000000..6b28fe2c71c
--- /dev/null
+++ b/tests/baselines/reference/templateStringInPropertyNameES6_2.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(2,5): error TS1136: Property assignment expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(2,32): error TS1005: ',' expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(2,34): error TS1134: Variable declaration expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(3,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts (4 errors) ====
+    var x = {
+        `abc${ 123 }def${ 456 }ghi`: 321
+        ~~~~~~
+!!! error TS1136: Property assignment expected.
+                                   ~
+!!! error TS1005: ',' expected.
+                                     ~~~
+!!! error TS1134: Variable declaration expected.
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInSwitchAndCase.js b/tests/baselines/reference/templateStringInSwitchAndCase.js
new file mode 100644
index 00000000000..67f182f8012
--- /dev/null
+++ b/tests/baselines/reference/templateStringInSwitchAndCase.js
@@ -0,0 +1,15 @@
+//// [templateStringInSwitchAndCase.ts]
+switch (`abc${0}abc`) {
+    case `abc`:
+    case `123`:
+    case `abc${0}abc`:
+        `def${1}def`;
+}
+
+//// [templateStringInSwitchAndCase.js]
+switch ("abc" + 0 + "abc") {
+    case "abc":
+    case "123":
+    case "abc" + 0 + "abc":
+        "def" + 1 + "def";
+}
diff --git a/tests/baselines/reference/templateStringInSwitchAndCase.types b/tests/baselines/reference/templateStringInSwitchAndCase.types
new file mode 100644
index 00000000000..26ec05dbca6
--- /dev/null
+++ b/tests/baselines/reference/templateStringInSwitchAndCase.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringInSwitchAndCase.ts ===
+switch (`abc${0}abc`) {
+No type information for this code.    case `abc`:
+No type information for this code.    case `123`:
+No type information for this code.    case `abc${0}abc`:
+No type information for this code.        `def${1}def`;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInSwitchAndCaseES6.js b/tests/baselines/reference/templateStringInSwitchAndCaseES6.js
new file mode 100644
index 00000000000..b52cb48cfde
--- /dev/null
+++ b/tests/baselines/reference/templateStringInSwitchAndCaseES6.js
@@ -0,0 +1,15 @@
+//// [templateStringInSwitchAndCaseES6.ts]
+switch (`abc${0}abc`) {
+    case `abc`:
+    case `123`:
+    case `abc${0}abc`:
+        `def${1}def`;
+}
+
+//// [templateStringInSwitchAndCaseES6.js]
+switch (`abc${0}abc`) {
+    case `abc`:
+    case `123`:
+    case `abc${0}abc`:
+        `def${1}def`;
+}
diff --git a/tests/baselines/reference/templateStringInSwitchAndCaseES6.types b/tests/baselines/reference/templateStringInSwitchAndCaseES6.types
new file mode 100644
index 00000000000..6bd8772ff49
--- /dev/null
+++ b/tests/baselines/reference/templateStringInSwitchAndCaseES6.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringInSwitchAndCaseES6.ts ===
+switch (`abc${0}abc`) {
+No type information for this code.    case `abc`:
+No type information for this code.    case `123`:
+No type information for this code.    case `abc${0}abc`:
+No type information for this code.        `def${1}def`;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInTypeAssertion.js b/tests/baselines/reference/templateStringInTypeAssertion.js
new file mode 100644
index 00000000000..94533248b6d
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeAssertion.js
@@ -0,0 +1,5 @@
+//// [templateStringInTypeAssertion.ts]
+var x = <any>`abc${ 123 }def`;
+
+//// [templateStringInTypeAssertion.js]
+var x = ("abc" + 123 + "def");
diff --git a/tests/baselines/reference/templateStringInTypeAssertion.types b/tests/baselines/reference/templateStringInTypeAssertion.types
new file mode 100644
index 00000000000..006ba12c1c6
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeAssertion.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInTypeAssertion.ts ===
+var x = <any>`abc${ 123 }def`;
+>x : any
+><any>`abc${ 123 }def` : any
+
diff --git a/tests/baselines/reference/templateStringInTypeAssertionES6.js b/tests/baselines/reference/templateStringInTypeAssertionES6.js
new file mode 100644
index 00000000000..08331911c7d
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeAssertionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInTypeAssertionES6.ts]
+var x = <any>`abc${ 123 }def`;
+
+//// [templateStringInTypeAssertionES6.js]
+var x = `abc${123}def`;
diff --git a/tests/baselines/reference/templateStringInTypeAssertionES6.types b/tests/baselines/reference/templateStringInTypeAssertionES6.types
new file mode 100644
index 00000000000..26d7ccc2e60
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeAssertionES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInTypeAssertionES6.ts ===
+var x = <any>`abc${ 123 }def`;
+>x : any
+><any>`abc${ 123 }def` : any
+
diff --git a/tests/baselines/reference/templateStringInTypeOf.js b/tests/baselines/reference/templateStringInTypeOf.js
new file mode 100644
index 00000000000..2543091df88
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeOf.js
@@ -0,0 +1,5 @@
+//// [templateStringInTypeOf.ts]
+var x = typeof `abc${ 123 }def`;
+
+//// [templateStringInTypeOf.js]
+var x = typeof ("abc" + 123 + "def");
diff --git a/tests/baselines/reference/templateStringInTypeOf.types b/tests/baselines/reference/templateStringInTypeOf.types
new file mode 100644
index 00000000000..8b94bc7ea1a
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeOf.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInTypeOf.ts ===
+var x = typeof `abc${ 123 }def`;
+>x : string
+>typeof `abc${ 123 }def` : string
+
diff --git a/tests/baselines/reference/templateStringInTypeOfES6.js b/tests/baselines/reference/templateStringInTypeOfES6.js
new file mode 100644
index 00000000000..e8566277449
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeOfES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInTypeOfES6.ts]
+var x = typeof `abc${ 123 }def`;
+
+//// [templateStringInTypeOfES6.js]
+var x = typeof `abc${123}def`;
diff --git a/tests/baselines/reference/templateStringInTypeOfES6.types b/tests/baselines/reference/templateStringInTypeOfES6.types
new file mode 100644
index 00000000000..457af8de0de
--- /dev/null
+++ b/tests/baselines/reference/templateStringInTypeOfES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInTypeOfES6.ts ===
+var x = typeof `abc${ 123 }def`;
+>x : string
+>typeof `abc${ 123 }def` : string
+
diff --git a/tests/baselines/reference/templateStringInUnaryPlus.js b/tests/baselines/reference/templateStringInUnaryPlus.js
new file mode 100644
index 00000000000..83f107b3ac2
--- /dev/null
+++ b/tests/baselines/reference/templateStringInUnaryPlus.js
@@ -0,0 +1,5 @@
+//// [templateStringInUnaryPlus.ts]
+var x = +`abc${ 123 }def`;
+
+//// [templateStringInUnaryPlus.js]
+var x = +("abc" + 123 + "def");
diff --git a/tests/baselines/reference/templateStringInUnaryPlus.types b/tests/baselines/reference/templateStringInUnaryPlus.types
new file mode 100644
index 00000000000..4746f2c1fc7
--- /dev/null
+++ b/tests/baselines/reference/templateStringInUnaryPlus.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInUnaryPlus.ts ===
+var x = +`abc${ 123 }def`;
+>x : number
+>+`abc${ 123 }def` : number
+
diff --git a/tests/baselines/reference/templateStringInUnaryPlusES6.js b/tests/baselines/reference/templateStringInUnaryPlusES6.js
new file mode 100644
index 00000000000..efeed300f7c
--- /dev/null
+++ b/tests/baselines/reference/templateStringInUnaryPlusES6.js
@@ -0,0 +1,5 @@
+//// [templateStringInUnaryPlusES6.ts]
+var x = +`abc${ 123 }def`;
+
+//// [templateStringInUnaryPlusES6.js]
+var x = +`abc${123}def`;
diff --git a/tests/baselines/reference/templateStringInUnaryPlusES6.types b/tests/baselines/reference/templateStringInUnaryPlusES6.types
new file mode 100644
index 00000000000..67ad03fc53c
--- /dev/null
+++ b/tests/baselines/reference/templateStringInUnaryPlusES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInUnaryPlusES6.ts ===
+var x = +`abc${ 123 }def`;
+>x : number
+>+`abc${ 123 }def` : number
+
diff --git a/tests/baselines/reference/templateStringInWhile.js b/tests/baselines/reference/templateStringInWhile.js
new file mode 100644
index 00000000000..31f7dba45d1
--- /dev/null
+++ b/tests/baselines/reference/templateStringInWhile.js
@@ -0,0 +1,9 @@
+//// [templateStringInWhile.ts]
+while (`abc${0}abc`) {
+    `def${1}def`;
+}
+
+//// [templateStringInWhile.js]
+while ("abc" + 0 + "abc") {
+    "def" + 1 + "def";
+}
diff --git a/tests/baselines/reference/templateStringInWhile.types b/tests/baselines/reference/templateStringInWhile.types
new file mode 100644
index 00000000000..1b080f31f1c
--- /dev/null
+++ b/tests/baselines/reference/templateStringInWhile.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInWhile.ts ===
+while (`abc${0}abc`) {
+No type information for this code.    `def${1}def`;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInWhileES6.js b/tests/baselines/reference/templateStringInWhileES6.js
new file mode 100644
index 00000000000..a4f19b80d0a
--- /dev/null
+++ b/tests/baselines/reference/templateStringInWhileES6.js
@@ -0,0 +1,9 @@
+//// [templateStringInWhileES6.ts]
+while (`abc${0}abc`) {
+    `def${1}def`;
+}
+
+//// [templateStringInWhileES6.js]
+while (`abc${0}abc`) {
+    `def${1}def`;
+}
diff --git a/tests/baselines/reference/templateStringInWhileES6.types b/tests/baselines/reference/templateStringInWhileES6.types
new file mode 100644
index 00000000000..d4ef3b02fe2
--- /dev/null
+++ b/tests/baselines/reference/templateStringInWhileES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringInWhileES6.ts ===
+while (`abc${0}abc`) {
+No type information for this code.    `def${1}def`;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
new file mode 100644
index 00000000000..be6fccbe1bc
--- /dev/null
+++ b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
@@ -0,0 +1,23 @@
+tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(1,9): error TS1003: Identifier expected.
+tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(1,15): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(3,13): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(1,11): error TS2304: Cannot find name 'gen'.
+tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(3,13): error TS2304: Cannot find name 'yield'.
+
+
+==== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts (5 errors) ====
+    function* gen {
+            ~
+!!! error TS1003: Identifier expected.
+                  ~
+!!! error TS1005: ';' expected.
+              ~~~
+!!! error TS2304: Cannot find name 'gen'.
+        // Once this is supported, the inner expression does not need to be parenthesized.
+        var x = yield `abc${ x }def`;
+                ~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                ~~~~~
+!!! error TS2304: Cannot find name 'yield'.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedAddition.js b/tests/baselines/reference/templateStringWithEmbeddedAddition.js
new file mode 100644
index 00000000000..2cf74941600
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedAddition.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedAddition.ts]
+var x = `abc${ 10 + 10 }def`;
+
+//// [templateStringWithEmbeddedAddition.js]
+var x = "abc" + (10 + 10) + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedAddition.types b/tests/baselines/reference/templateStringWithEmbeddedAddition.types
new file mode 100644
index 00000000000..3a6bf864cb6
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedAddition.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedAddition.ts ===
+var x = `abc${ 10 + 10 }def`;
+>x : string
+>10 + 10 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedAdditionES6.js b/tests/baselines/reference/templateStringWithEmbeddedAdditionES6.js
new file mode 100644
index 00000000000..72beea32d57
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedAdditionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedAdditionES6.ts]
+var x = `abc${ 10 + 10 }def`;
+
+//// [templateStringWithEmbeddedAdditionES6.js]
+var x = `abc${10 + 10}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedAdditionES6.types b/tests/baselines/reference/templateStringWithEmbeddedAdditionES6.types
new file mode 100644
index 00000000000..699162a3783
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedAdditionES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedAdditionES6.ts ===
+var x = `abc${ 10 + 10 }def`;
+>x : string
+>10 + 10 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArray.js b/tests/baselines/reference/templateStringWithEmbeddedArray.js
new file mode 100644
index 00000000000..1fb6512db47
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArray.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedArray.ts]
+var x = `abc${ [1,2,3] }def`;
+
+//// [templateStringWithEmbeddedArray.js]
+var x = "abc" + [1, 2, 3] + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArray.types b/tests/baselines/reference/templateStringWithEmbeddedArray.types
new file mode 100644
index 00000000000..4c022d8a401
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArray.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedArray.ts ===
+var x = `abc${ [1,2,3] }def`;
+>x : string
+>[1,2,3] : number[]
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrayES6.js b/tests/baselines/reference/templateStringWithEmbeddedArrayES6.js
new file mode 100644
index 00000000000..804ef7a4e78
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrayES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedArrayES6.ts]
+var x = `abc${ [1,2,3] }def`;
+
+//// [templateStringWithEmbeddedArrayES6.js]
+var x = `abc${[1, 2, 3]}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrayES6.types b/tests/baselines/reference/templateStringWithEmbeddedArrayES6.types
new file mode 100644
index 00000000000..06876fa3f0e
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrayES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrayES6.ts ===
+var x = `abc${ [1,2,3] }def`;
+>x : string
+>[1,2,3] : number[]
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.js b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.js
new file mode 100644
index 00000000000..eb2579b0cc3
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedArrowFunction.ts]
+var x = `abc${ x => x }def`;
+
+//// [templateStringWithEmbeddedArrowFunction.js]
+var x = "abc" + function (x) { return x; } + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.types b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.types
new file mode 100644
index 00000000000..d6f25761999
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunction.ts ===
+var x = `abc${ x => x }def`;
+>x : string
+>x => x : (x: any) => any
+>x : any
+>x : any
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.js b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.js
new file mode 100644
index 00000000000..f6f068aaa37
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedArrowFunctionES6.ts]
+var x = `abc${ x => x }def`;
+
+//// [templateStringWithEmbeddedArrowFunctionES6.js]
+var x = `abc${function (x) { return x; }}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.types b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.types
new file mode 100644
index 00000000000..748f457f22b
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunctionES6.ts ===
+var x = `abc${ x => x }def`;
+>x : string
+>x => x : (x: any) => any
+>x : any
+>x : any
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedComments.js b/tests/baselines/reference/templateStringWithEmbeddedComments.js
new file mode 100644
index 00000000000..58a73e89ba7
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedComments.js
@@ -0,0 +1,16 @@
+//// [templateStringWithEmbeddedComments.ts]
+`head${ // single line comment
+10
+}
+middle${
+/* Multi-
+ * line
+ * comment
+ */
+ 20
+ // closing comment
+}
+tail`;
+
+//// [templateStringWithEmbeddedComments.js]
+"head" + 10 + "\nmiddle" + 20 + "\ntail";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedComments.types b/tests/baselines/reference/templateStringWithEmbeddedComments.types
new file mode 100644
index 00000000000..a375ef6ab6f
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedComments.types
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedComments.ts ===
+`head${ // single line comment
+No type information for this code.10
+No type information for this code.}
+No type information for this code.middle${
+No type information for this code./* Multi-
+No type information for this code. * line
+No type information for this code. * comment
+No type information for this code. */
+No type information for this code. 20
+No type information for this code. // closing comment
+No type information for this code.}
+No type information for this code.tail`;
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedCommentsES6.js b/tests/baselines/reference/templateStringWithEmbeddedCommentsES6.js
new file mode 100644
index 00000000000..c6b3649ad2a
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedCommentsES6.js
@@ -0,0 +1,16 @@
+//// [templateStringWithEmbeddedCommentsES6.ts]
+`head${ // single line comment
+10
+}
+middle${
+/* Multi-
+ * line
+ * comment
+ */
+ 20
+ // closing comment
+}
+tail`;
+
+//// [templateStringWithEmbeddedCommentsES6.js]
+"head" + 10 + "\nmiddle" + 20 + "\ntail";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedCommentsES6.types b/tests/baselines/reference/templateStringWithEmbeddedCommentsES6.types
new file mode 100644
index 00000000000..0c79ee294d9
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedCommentsES6.types
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedCommentsES6.ts ===
+`head${ // single line comment
+No type information for this code.10
+No type information for this code.}
+No type information for this code.middle${
+No type information for this code./* Multi-
+No type information for this code. * line
+No type information for this code. * comment
+No type information for this code. */
+No type information for this code. 20
+No type information for this code. // closing comment
+No type information for this code.}
+No type information for this code.tail`;
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedConditional.js b/tests/baselines/reference/templateStringWithEmbeddedConditional.js
new file mode 100644
index 00000000000..5b03f56a019
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedConditional.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedConditional.ts]
+var x = `abc${ true ? false : " " }def`;
+
+//// [templateStringWithEmbeddedConditional.js]
+var x = "abc" + (true ? false : " ") + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedConditional.types b/tests/baselines/reference/templateStringWithEmbeddedConditional.types
new file mode 100644
index 00000000000..de4249792e7
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedConditional.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditional.ts ===
+var x = `abc${ true ? false : " " }def`;
+>x : string
+>true ? false : " " : string | boolean
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedConditionalES6.js b/tests/baselines/reference/templateStringWithEmbeddedConditionalES6.js
new file mode 100644
index 00000000000..f6cae50a511
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedConditionalES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedConditionalES6.ts]
+var x = `abc${ true ? false : " " }def`;
+
+//// [templateStringWithEmbeddedConditionalES6.js]
+var x = `abc${true ? false : " "}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedConditionalES6.types b/tests/baselines/reference/templateStringWithEmbeddedConditionalES6.types
new file mode 100644
index 00000000000..3fa96510f41
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedConditionalES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditionalES6.ts ===
+var x = `abc${ true ? false : " " }def`;
+>x : string
+>true ? false : " " : string | boolean
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedDivision.js b/tests/baselines/reference/templateStringWithEmbeddedDivision.js
new file mode 100644
index 00000000000..f9996ae035d
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedDivision.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedDivision.ts]
+var x = `abc${ 1 / 1 }def`;
+
+//// [templateStringWithEmbeddedDivision.js]
+var x = "abc" + 1 / 1 + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedDivision.types b/tests/baselines/reference/templateStringWithEmbeddedDivision.types
new file mode 100644
index 00000000000..e742733a23c
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedDivision.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivision.ts ===
+var x = `abc${ 1 / 1 }def`;
+>x : string
+>1 / 1 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedDivisionES6.js b/tests/baselines/reference/templateStringWithEmbeddedDivisionES6.js
new file mode 100644
index 00000000000..47715d3f31b
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedDivisionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedDivisionES6.ts]
+var x = `abc${ 1 / 1 }def`;
+
+//// [templateStringWithEmbeddedDivisionES6.js]
+var x = `abc${1 / 1}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedDivisionES6.types b/tests/baselines/reference/templateStringWithEmbeddedDivisionES6.types
new file mode 100644
index 00000000000..20bdc9449d1
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedDivisionES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivisionES6.ts ===
+var x = `abc${ 1 / 1 }def`;
+>x : string
+>1 / 1 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.js b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.js
new file mode 100644
index 00000000000..3447ff87ac3
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.js
@@ -0,0 +1,7 @@
+//// [templateStringWithEmbeddedFunctionExpression.ts]
+var x = `abc${ function y() { return y; } }def`;
+
+//// [templateStringWithEmbeddedFunctionExpression.js]
+var x = "abc" + function y() {
+    return y;
+} + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.types b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.types
new file mode 100644
index 00000000000..e66313848a6
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpression.ts ===
+var x = `abc${ function y() { return y; } }def`;
+>x : string
+>function y() { return y; } : () => any
+>y : () => any
+>y : () => any
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.js b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.js
new file mode 100644
index 00000000000..46e37c0ac18
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.js
@@ -0,0 +1,7 @@
+//// [templateStringWithEmbeddedFunctionExpressionES6.ts]
+var x = `abc${ function y() { return y; } }def`;
+
+//// [templateStringWithEmbeddedFunctionExpressionES6.js]
+var x = `abc${function y() {
+    return y;
+}}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.types b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.types
new file mode 100644
index 00000000000..e5c55c2736c
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpressionES6.ts ===
+var x = `abc${ function y() { return y; } }def`;
+>x : string
+>function y() { return y; } : () => any
+>y : () => any
+>y : () => any
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperator.js b/tests/baselines/reference/templateStringWithEmbeddedInOperator.js
new file mode 100644
index 00000000000..091843ea52e
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperator.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedInOperator.ts]
+var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
+
+//// [templateStringWithEmbeddedInOperator.js]
+var x = "abc" + ("hi" in { hi: 10, hello: 20 }) + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperator.types b/tests/baselines/reference/templateStringWithEmbeddedInOperator.types
new file mode 100644
index 00000000000..bff1ea66e1d
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperator.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperator.ts ===
+var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
+>x : string
+>"hi" in { hi: 10, hello: 20} : boolean
+>{ hi: 10, hello: 20} : { hi: number; hello: number; }
+>hi : number
+>hello : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.js b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.js
new file mode 100644
index 00000000000..f6510c2fab9
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedInOperatorES6.ts]
+var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
+
+//// [templateStringWithEmbeddedInOperatorES6.js]
+var x = `abc${"hi" in { hi: 10, hello: 20 }}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.types b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.types
new file mode 100644
index 00000000000..6bba79af40d
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperatorES6.ts ===
+var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
+>x : string
+>"hi" in { hi: 10, hello: 20} : boolean
+>{ hi: 10, hello: 20} : { hi: number; hello: number; }
+>hi : number
+>hello : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInstanceOf.errors.txt b/tests/baselines/reference/templateStringWithEmbeddedInstanceOf.errors.txt
new file mode 100644
index 00000000000..08c8c21b5ee
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInstanceOf.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOf.ts(1,16): error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
+
+
+==== tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOf.ts (1 errors) ====
+    var x = `abc${ "hello" instanceof String }def`;
+                   ~~~~~~~
+!!! error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInstanceOf.js b/tests/baselines/reference/templateStringWithEmbeddedInstanceOf.js
new file mode 100644
index 00000000000..009f6bf988d
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInstanceOf.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedInstanceOf.ts]
+var x = `abc${ "hello" instanceof String }def`;
+
+//// [templateStringWithEmbeddedInstanceOf.js]
+var x = "abc" + ("hello" instanceof String) + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.errors.txt b/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.errors.txt
new file mode 100644
index 00000000000..85ebb9966ca
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOfES6.ts(1,16): error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
+
+
+==== tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOfES6.ts (1 errors) ====
+    var x = `abc${ "hello" instanceof String }def`;
+                   ~~~~~~~
+!!! error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.js b/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.js
new file mode 100644
index 00000000000..16a2d2c6797
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedInstanceOfES6.ts]
+var x = `abc${ "hello" instanceof String }def`;
+
+//// [templateStringWithEmbeddedInstanceOfES6.js]
+var x = `abc${"hello" instanceof String}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedModulo.js b/tests/baselines/reference/templateStringWithEmbeddedModulo.js
new file mode 100644
index 00000000000..6fe9be64314
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedModulo.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedModulo.ts]
+var x = `abc${ 1 % 1 }def`;
+
+//// [templateStringWithEmbeddedModulo.js]
+var x = "abc" + 1 % 1 + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedModulo.types b/tests/baselines/reference/templateStringWithEmbeddedModulo.types
new file mode 100644
index 00000000000..0c24f566846
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedModulo.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedModulo.ts ===
+var x = `abc${ 1 % 1 }def`;
+>x : string
+>1 % 1 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedModuloES6.js b/tests/baselines/reference/templateStringWithEmbeddedModuloES6.js
new file mode 100644
index 00000000000..0226277d987
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedModuloES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedModuloES6.ts]
+var x = `abc${ 1 % 1 }def`;
+
+//// [templateStringWithEmbeddedModuloES6.js]
+var x = `abc${1 % 1}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedModuloES6.types b/tests/baselines/reference/templateStringWithEmbeddedModuloES6.types
new file mode 100644
index 00000000000..02f42a956b9
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedModuloES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedModuloES6.ts ===
+var x = `abc${ 1 % 1 }def`;
+>x : string
+>1 % 1 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedMultiplication.js b/tests/baselines/reference/templateStringWithEmbeddedMultiplication.js
new file mode 100644
index 00000000000..7ac4b1b534c
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedMultiplication.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedMultiplication.ts]
+var x = `abc${ 7 * 6 }def`;
+
+//// [templateStringWithEmbeddedMultiplication.js]
+var x = "abc" + 7 * 6 + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedMultiplication.types b/tests/baselines/reference/templateStringWithEmbeddedMultiplication.types
new file mode 100644
index 00000000000..60c7bab0d1e
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedMultiplication.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplication.ts ===
+var x = `abc${ 7 * 6 }def`;
+>x : string
+>7 * 6 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedMultiplicationES6.js b/tests/baselines/reference/templateStringWithEmbeddedMultiplicationES6.js
new file mode 100644
index 00000000000..3624fe7878a
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedMultiplicationES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedMultiplicationES6.ts]
+var x = `abc${ 7 * 6 }def`;
+
+//// [templateStringWithEmbeddedMultiplicationES6.js]
+var x = `abc${7 * 6}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedMultiplicationES6.types b/tests/baselines/reference/templateStringWithEmbeddedMultiplicationES6.types
new file mode 100644
index 00000000000..5c078b9c1ed
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedMultiplicationES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplicationES6.ts ===
+var x = `abc${ 7 * 6 }def`;
+>x : string
+>7 * 6 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperator.js b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.js
new file mode 100644
index 00000000000..480fbe2573d
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedNewOperator.ts]
+var x = `abc${ new String("Hi") }def`;
+
+//// [templateStringWithEmbeddedNewOperator.js]
+var x = "abc" + new String("Hi") + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperator.types b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.types
new file mode 100644
index 00000000000..00bf3533003
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperator.ts ===
+var x = `abc${ new String("Hi") }def`;
+>x : string
+>new String("Hi") : String
+>String : { (value?: any): string; new (value?: any): String; prototype: String; fromCharCode(...codes: number[]): string; }
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.js b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.js
new file mode 100644
index 00000000000..8549e4c6e34
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedNewOperatorES6.ts]
+var x = `abc${ new String("Hi") }def`;
+
+//// [templateStringWithEmbeddedNewOperatorES6.js]
+var x = `abc${new String("Hi")}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.types b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.types
new file mode 100644
index 00000000000..36c28473d56
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts ===
+var x = `abc${ new String("Hi") }def`;
+>x : string
+>new String("Hi") : String
+>String : { (value?: any): string; new (value?: any): String; prototype: String; fromCharCode(...codes: number[]): string; }
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.js b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.js
new file mode 100644
index 00000000000..40ecf486245
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedObjectLiteral.ts]
+var x = `abc${ { x: 10, y: 20 } }def`;
+
+//// [templateStringWithEmbeddedObjectLiteral.js]
+var x = "abc" + { x: 10, y: 20 } + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.types b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.types
new file mode 100644
index 00000000000..0b053e532d8
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteral.ts ===
+var x = `abc${ { x: 10, y: 20 } }def`;
+>x : string
+>{ x: 10, y: 20 } : { x: number; y: number; }
+>x : number
+>y : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.js b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.js
new file mode 100644
index 00000000000..dbc3837e133
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedObjectLiteralES6.ts]
+var x = `abc${ { x: 10, y: 20 } }def`;
+
+//// [templateStringWithEmbeddedObjectLiteralES6.js]
+var x = `abc${{ x: 10, y: 20 }}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.types b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.types
new file mode 100644
index 00000000000..1cf1783fec8
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteralES6.ts ===
+var x = `abc${ { x: 10, y: 20 } }def`;
+>x : string
+>{ x: 10, y: 20 } : { x: number; y: number; }
+>x : number
+>y : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTemplateString.js b/tests/baselines/reference/templateStringWithEmbeddedTemplateString.js
new file mode 100644
index 00000000000..c0059dbb950
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTemplateString.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedTemplateString.ts]
+var x = `123${ `456 ${ " | " } 654` }321 123${ `456 ${ " | " } 654` }321`;
+
+//// [templateStringWithEmbeddedTemplateString.js]
+var x = "123" + "456 " + " | " + " 654" + "321 123" + "456 " + " | " + " 654" + "321";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTemplateString.types b/tests/baselines/reference/templateStringWithEmbeddedTemplateString.types
new file mode 100644
index 00000000000..f63f684222e
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTemplateString.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateString.ts ===
+var x = `123${ `456 ${ " | " } 654` }321 123${ `456 ${ " | " } 654` }321`;
+>x : string
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTemplateStringES6.js b/tests/baselines/reference/templateStringWithEmbeddedTemplateStringES6.js
new file mode 100644
index 00000000000..0d1fec18af1
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTemplateStringES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedTemplateStringES6.ts]
+var x = `123${ `456 ${ " | " } 654` }321 123${ `456 ${ " | " } 654` }321`;
+
+//// [templateStringWithEmbeddedTemplateStringES6.js]
+var x = `123${`456 ${" | "} 654`}321 123${`456 ${" | "} 654`}321`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTemplateStringES6.types b/tests/baselines/reference/templateStringWithEmbeddedTemplateStringES6.types
new file mode 100644
index 00000000000..05816bbcbce
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTemplateStringES6.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateStringES6.ts ===
+var x = `123${ `456 ${ " | " } 654` }321 123${ `456 ${ " | " } 654` }321`;
+>x : string
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAddition.js b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAddition.js
new file mode 100644
index 00000000000..89d9ba6940c
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAddition.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedTypeAssertionOnAddition.ts]
+var x = `abc${ <any>(10 + 10) }def`;
+
+//// [templateStringWithEmbeddedTypeAssertionOnAddition.js]
+var x = "abc" + (10 + 10) + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAddition.types b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAddition.types
new file mode 100644
index 00000000000..8b0b5ab37d0
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAddition.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAddition.ts ===
+var x = `abc${ <any>(10 + 10) }def`;
+>x : string
+><any>(10 + 10) : any
+>(10 + 10) : number
+>10 + 10 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAdditionES6.js b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAdditionES6.js
new file mode 100644
index 00000000000..c6422679f3f
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAdditionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedTypeAssertionOnAdditionES6.ts]
+var x = `abc${ <any>(10 + 10) }def`;
+
+//// [templateStringWithEmbeddedTypeAssertionOnAdditionES6.js]
+var x = `abc${(10 + 10)}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAdditionES6.types b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAdditionES6.types
new file mode 100644
index 00000000000..007fdb64736
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeAssertionOnAdditionES6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAdditionES6.ts ===
+var x = `abc${ <any>(10 + 10) }def`;
+>x : string
+><any>(10 + 10) : any
+>(10 + 10) : number
+>10 + 10 : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperator.js b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperator.js
new file mode 100644
index 00000000000..10450707b11
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperator.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedTypeOfOperator.ts]
+var x = `abc${ typeof "hi" }def`;
+
+//// [templateStringWithEmbeddedTypeOfOperator.js]
+var x = "abc" + typeof "hi" + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperator.types b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperator.types
new file mode 100644
index 00000000000..ebf391981f1
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperator.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperator.ts ===
+var x = `abc${ typeof "hi" }def`;
+>x : string
+>typeof "hi" : string
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperatorES6.js b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperatorES6.js
new file mode 100644
index 00000000000..8d148744fae
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperatorES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedTypeOfOperatorES6.ts]
+var x = `abc${ typeof "hi" }def`;
+
+//// [templateStringWithEmbeddedTypeOfOperatorES6.js]
+var x = `abc${typeof "hi"}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperatorES6.types b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperatorES6.types
new file mode 100644
index 00000000000..cf14a0a0880
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedTypeOfOperatorES6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperatorES6.ts ===
+var x = `abc${ typeof "hi" }def`;
+>x : string
+>typeof "hi" : string
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.js b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.js
new file mode 100644
index 00000000000..a4a9c1a8508
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedUnaryPlus.ts]
+var x = `abc${ +Infinity }def`;
+
+//// [templateStringWithEmbeddedUnaryPlus.js]
+var x = "abc" + +Infinity + "def";
diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.types b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.types
new file mode 100644
index 00000000000..62ffab420ad
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlus.ts ===
+var x = `abc${ +Infinity }def`;
+>x : string
+>+Infinity : number
+>Infinity : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.js b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.js
new file mode 100644
index 00000000000..4b42bc1083a
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithEmbeddedUnaryPlusES6.ts]
+var x = `abc${ +Infinity }def`;
+
+//// [templateStringWithEmbeddedUnaryPlusES6.js]
+var x = `abc${+Infinity}def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.types b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.types
new file mode 100644
index 00000000000..7a002d79b6f
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlusES6.ts ===
+var x = `abc${ +Infinity }def`;
+>x : string
+>+Infinity : number
+>Infinity : number
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt
new file mode 100644
index 00000000000..e5f159a0a13
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt
@@ -0,0 +1,34 @@
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(1,9): error TS1003: Identifier expected.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(1,15): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(3,26): error TS1159: Invalid template literal; expected '}'
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(3,30): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(5,1): error TS1126: Unexpected end of text.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(1,11): error TS2304: Cannot find name 'gen'.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(3,20): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(3,30): error TS2304: Cannot find name 'def'.
+
+
+==== tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts (8 errors) ====
+    function* gen {
+            ~
+!!! error TS1003: Identifier expected.
+                  ~
+!!! error TS1005: ';' expected.
+              ~~~
+!!! error TS2304: Cannot find name 'gen'.
+        // Once this is supported, yield *must* be parenthesized.
+        var x = `abc${ yield 10 }def`;
+                             ~~
+!!! error TS1159: Invalid template literal; expected '}'
+                                 ~~~~~
+                       ~~~~~
+!!! error TS2304: Cannot find name 'yield'.
+                                 ~~~
+!!! error TS2304: Cannot find name 'def'.
+    }
+    ~
+    
+    
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+!!! error TS1126: Unexpected end of text.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt
new file mode 100644
index 00000000000..45142cd02d9
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt
@@ -0,0 +1,29 @@
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(1,9): error TS1003: Identifier expected.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(1,17): error TS1005: ';' expected.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(3,26): error TS1159: Invalid template literal; expected '}'
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(5,1): error TS1126: Unexpected end of text.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(1,11): error TS2304: Cannot find name 'gen'.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(3,20): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(3,30): error TS2304: Cannot find name 'def'.
+
+
+==== tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts (7 errors) ====
+    function* gen() {
+            ~
+!!! error TS1003: Identifier expected.
+                    ~
+!!! error TS1005: ';' expected.
+              ~~~
+!!! error TS2304: Cannot find name 'gen'.
+        // Once this is supported, yield *must* be parenthesized.
+        var x = `abc${ yield 10 }def`;
+                             ~~
+!!! error TS1159: Invalid template literal; expected '}'
+                       ~~~~~
+!!! error TS2304: Cannot find name 'yield'.
+                                 ~~~
+!!! error TS2304: Cannot find name 'def'.
+    }
+    
+    
+!!! error TS1126: Unexpected end of text.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortions.js b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.js
new file mode 100644
index 00000000000..8bc6e2c4206
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.js
@@ -0,0 +1,38 @@
+//// [templateStringWithEmptyLiteralPortions.ts]
+var a = ``;
+
+var b = `${ 0 }`;
+
+var c = `1${ 0 }`;
+
+var d = `${ 0 }2`;
+
+var e = `1${ 0 }2`;
+
+var f = `${ 0 }${ 0 }`;
+
+var g = `1${ 0 }${ 0 }`;
+
+var h = `${ 0 }2${ 0 }`;
+
+var i = `1${ 0 }2${ 0 }`;
+
+var j = `${ 0 }${ 0 }3`;
+
+var k = `1${ 0 }${ 0 }3`;
+
+var l = `1${ 0 }2${ 0 }3`;
+
+//// [templateStringWithEmptyLiteralPortions.js]
+var a = "";
+var b = "" + 0;
+var c = "1" + 0;
+var d = "" + 0 + "2";
+var e = "1" + 0 + "2";
+var f = "" + 0 + 0;
+var g = "1" + 0 + 0;
+var h = "" + 0 + "2" + 0;
+var i = "1" + 0 + "2" + 0;
+var j = "" + 0 + 0 + "3";
+var k = "1" + 0 + 0 + "3";
+var l = "1" + 0 + "2" + 0 + "3";
diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortions.types b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.types
new file mode 100644
index 00000000000..a44bab8fe44
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts ===
+var a = ``;
+>a : string
+
+var b = `${ 0 }`;
+>b : string
+
+var c = `1${ 0 }`;
+>c : string
+
+var d = `${ 0 }2`;
+>d : string
+
+var e = `1${ 0 }2`;
+>e : string
+
+var f = `${ 0 }${ 0 }`;
+>f : string
+
+var g = `1${ 0 }${ 0 }`;
+>g : string
+
+var h = `${ 0 }2${ 0 }`;
+>h : string
+
+var i = `1${ 0 }2${ 0 }`;
+>i : string
+
+var j = `${ 0 }${ 0 }3`;
+>j : string
+
+var k = `1${ 0 }${ 0 }3`;
+>k : string
+
+var l = `1${ 0 }2${ 0 }3`;
+>l : string
+
diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.js b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.js
new file mode 100644
index 00000000000..f0e827cde63
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.js
@@ -0,0 +1,38 @@
+//// [templateStringWithEmptyLiteralPortionsES6.ts]
+var a = ``;
+
+var b = `${ 0 }`;
+
+var c = `1${ 0 }`;
+
+var d = `${ 0 }2`;
+
+var e = `1${ 0 }2`;
+
+var f = `${ 0 }${ 0 }`;
+
+var g = `1${ 0 }${ 0 }`;
+
+var h = `${ 0 }2${ 0 }`;
+
+var i = `1${ 0 }2${ 0 }`;
+
+var j = `${ 0 }${ 0 }3`;
+
+var k = `1${ 0 }${ 0 }3`;
+
+var l = `1${ 0 }2${ 0 }3`;
+
+//// [templateStringWithEmptyLiteralPortionsES6.js]
+var a = ``;
+var b = `${0}`;
+var c = `1${0}`;
+var d = `${0}2`;
+var e = `1${0}2`;
+var f = `${0}${0}`;
+var g = `1${0}${0}`;
+var h = `${0}2${0}`;
+var i = `1${0}2${0}`;
+var j = `${0}${0}3`;
+var k = `1${0}${0}3`;
+var l = `1${0}2${0}3`;
diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.types b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.types
new file mode 100644
index 00000000000..4074831d410
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts ===
+var a = ``;
+>a : string
+
+var b = `${ 0 }`;
+>b : string
+
+var c = `1${ 0 }`;
+>c : string
+
+var d = `${ 0 }2`;
+>d : string
+
+var e = `1${ 0 }2`;
+>e : string
+
+var f = `${ 0 }${ 0 }`;
+>f : string
+
+var g = `1${ 0 }${ 0 }`;
+>g : string
+
+var h = `${ 0 }2${ 0 }`;
+>h : string
+
+var i = `1${ 0 }2${ 0 }`;
+>i : string
+
+var j = `${ 0 }${ 0 }3`;
+>j : string
+
+var k = `1${ 0 }${ 0 }3`;
+>k : string
+
+var l = `1${ 0 }2${ 0 }3`;
+>l : string
+
diff --git a/tests/baselines/reference/templateStringWithOpenCommentInStringPortion.js b/tests/baselines/reference/templateStringWithOpenCommentInStringPortion.js
new file mode 100644
index 00000000000..233ab78a195
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithOpenCommentInStringPortion.js
@@ -0,0 +1,5 @@
+//// [templateStringWithOpenCommentInStringPortion.ts]
+` /**head  ${ 10 } // still middle  ${ 20 } /* still tail `
+
+//// [templateStringWithOpenCommentInStringPortion.js]
+" /**head  " + 10 + " // still middle  " + 20 + " /* still tail ";
diff --git a/tests/baselines/reference/templateStringWithOpenCommentInStringPortion.types b/tests/baselines/reference/templateStringWithOpenCommentInStringPortion.types
new file mode 100644
index 00000000000..66070a70ec7
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithOpenCommentInStringPortion.types
@@ -0,0 +1,3 @@
+=== tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortion.ts ===
+` /**head  ${ 10 } // still middle  ${ 20 } /* still tail `
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithOpenCommentInStringPortionES6.js b/tests/baselines/reference/templateStringWithOpenCommentInStringPortionES6.js
new file mode 100644
index 00000000000..45d2d86e97e
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithOpenCommentInStringPortionES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithOpenCommentInStringPortionES6.ts]
+` /**head  ${ 10 } // still middle  ${ 20 } /* still tail `
+
+//// [templateStringWithOpenCommentInStringPortionES6.js]
+` /**head  ${10} // still middle  ${20} /* still tail `;
diff --git a/tests/baselines/reference/templateStringWithOpenCommentInStringPortionES6.types b/tests/baselines/reference/templateStringWithOpenCommentInStringPortionES6.types
new file mode 100644
index 00000000000..08b5484f3ab
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithOpenCommentInStringPortionES6.types
@@ -0,0 +1,3 @@
+=== tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortionES6.ts ===
+` /**head  ${ 10 } // still middle  ${ 20 } /* still tail `
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithPropertyAccess.js b/tests/baselines/reference/templateStringWithPropertyAccess.js
new file mode 100644
index 00000000000..9866b6bd53b
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithPropertyAccess.js
@@ -0,0 +1,5 @@
+//// [templateStringWithPropertyAccess.ts]
+`abc${0}abc`.indexOf(`abc`);
+
+//// [templateStringWithPropertyAccess.js]
+("abc" + 0 + "abc").indexOf("abc");
diff --git a/tests/baselines/reference/templateStringWithPropertyAccess.types b/tests/baselines/reference/templateStringWithPropertyAccess.types
new file mode 100644
index 00000000000..ae9dbb5249d
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithPropertyAccess.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/templates/templateStringWithPropertyAccess.ts ===
+`abc${0}abc`.indexOf(`abc`);
+>`abc${0}abc`.indexOf(`abc`) : number
+>`abc${0}abc`.indexOf : (searchString: string, position?: number) => number
+>indexOf : (searchString: string, position?: number) => number
+
diff --git a/tests/baselines/reference/templateStringWithPropertyAccessES6.js b/tests/baselines/reference/templateStringWithPropertyAccessES6.js
new file mode 100644
index 00000000000..72f3a16b5c4
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithPropertyAccessES6.js
@@ -0,0 +1,5 @@
+//// [templateStringWithPropertyAccessES6.ts]
+`abc${0}abc`.indexOf(`abc`);
+
+//// [templateStringWithPropertyAccessES6.js]
+`abc${0}abc`.indexOf(`abc`);
diff --git a/tests/baselines/reference/templateStringWithPropertyAccessES6.types b/tests/baselines/reference/templateStringWithPropertyAccessES6.types
new file mode 100644
index 00000000000..80ea8a0ef8b
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithPropertyAccessES6.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/templates/templateStringWithPropertyAccessES6.ts ===
+`abc${0}abc`.indexOf(`abc`);
+>`abc${0}abc`.indexOf(`abc`) : number
+>`abc${0}abc`.indexOf : (searchString: string, position?: number) => number
+>indexOf : (searchString: string, position?: number) => number
+
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts
new file mode 100644
index 00000000000..cd9da4e43e4
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts
@@ -0,0 +1,30 @@
+interface I {
+    (stringParts: string[], ...rest: boolean[]): I;
+    g: I;
+    h: I;
+    member: I;
+    thisIsNotATag(x: string): void
+    [x: number]: I;
+}
+
+var f: I;
+
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts
new file mode 100644
index 00000000000..2e8cbf3a1fa
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts
@@ -0,0 +1,31 @@
+// @target: ES6
+interface I {
+    (stringParts: string[], ...rest: boolean[]): I;
+    g: I;
+    h: I;
+    member: I;
+    thisIsNotATag(x: string): void
+    [x: number]: I;
+}
+
+var f: I;
+
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts
new file mode 100644
index 00000000000..b86996a53f3
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts
@@ -0,0 +1,14 @@
+interface I {
+    (strs: string[], subs: number[]): I;
+    member: {
+        new (s: string): {
+            new (n: number): {
+                new (): boolean;
+            }
+        }
+    };
+}
+var f: I;
+
+var x = new new new f `abc${ 0 }def`.member("hello")(42) === true;
+
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts
new file mode 100644
index 00000000000..0fe9ad566a9
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts
@@ -0,0 +1,15 @@
+// @target: ES6
+interface I {
+    (strs: string[], subs: number[]): I;
+    member: {
+        new (s: string): {
+            new (n: number): {
+                new (): boolean;
+            }
+        }
+    };
+}
+var f: I;
+
+var x = new new new f `abc${ 0 }def`.member("hello")(42) === true;
+
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts
new file mode 100644
index 00000000000..08d696cb288
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts
@@ -0,0 +1,25 @@
+var f: any;
+
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f.g.h `abc`
+
+f.g.h `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`["member"].someOtherTag `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].someOtherTag `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAnyES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAnyES6.ts
new file mode 100644
index 00000000000..de75e1679ac
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAnyES6.ts
@@ -0,0 +1,25 @@
+// @target: ES6
+var f: any;
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f.g.h `abc`
+
+f.g.h `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`["member"].someOtherTag `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].someOtherTag `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts
new file mode 100644
index 00000000000..9b3852c2ddb
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts
@@ -0,0 +1,30 @@
+interface I {
+    (stringParts: string[], ...rest: number[]): I;
+    g: I;
+    h: I;
+    member: I;
+    thisIsNotATag(x: string): void
+    [x: number]: I;
+}
+
+var f: I;
+
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts
new file mode 100644
index 00000000000..0dc10820a98
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts
@@ -0,0 +1,31 @@
+// @target: ES6
+interface I {
+    (stringParts: string[], ...rest: number[]): I;
+    g: I;
+    h: I;
+    member: I;
+    thisIsNotATag(x: string): void
+    [x: number]: I;
+}
+
+var f: I;
+
+f `abc`
+
+f `abc${1}def${2}ghi`;
+
+f `abc`.member
+
+f `abc${1}def${2}ghi`.member;
+
+f `abc`["member"];
+
+f `abc${1}def${2}ghi`["member"];
+
+f `abc`[0].member `abc${1}def${2}ghi`;
+
+f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+
+f.thisIsNotATag(`abc`);
+
+f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/cases/conformance/es6/templates/templateStringInArray.ts b/tests/cases/conformance/es6/templates/templateStringInArray.ts
new file mode 100644
index 00000000000..2d2e5e323b5
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInArray.ts
@@ -0,0 +1 @@
+var x = [1, 2, `abc${ 123 }def`];
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInArrowFunction.ts b/tests/cases/conformance/es6/templates/templateStringInArrowFunction.ts
new file mode 100644
index 00000000000..9820edb2ac3
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInArrowFunction.ts
@@ -0,0 +1 @@
+var x = x => `abc${ x }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInArrowFunctionES6.ts b/tests/cases/conformance/es6/templates/templateStringInArrowFunctionES6.ts
new file mode 100644
index 00000000000..066fc1c74b1
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInArrowFunctionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = x => `abc${ x }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInBinaryAddition.ts b/tests/cases/conformance/es6/templates/templateStringInBinaryAddition.ts
new file mode 100644
index 00000000000..7f00313ca86
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInBinaryAddition.ts
@@ -0,0 +1 @@
+var x = 10 + `abc${ 10 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInBinaryAdditionES6.ts b/tests/cases/conformance/es6/templates/templateStringInBinaryAdditionES6.ts
new file mode 100644
index 00000000000..5f44e3cb9d4
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInBinaryAdditionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = 10 + `abc${ 10 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInConditional.ts b/tests/cases/conformance/es6/templates/templateStringInConditional.ts
new file mode 100644
index 00000000000..aff80b60efc
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInConditional.ts
@@ -0,0 +1 @@
+var x = `abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInConditionalES6.ts b/tests/cases/conformance/es6/templates/templateStringInConditionalES6.ts
new file mode 100644
index 00000000000..c0b800259f3
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInConditionalES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ " " }def` ? `abc${ " " }def` : `abc${ " " }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInDeleteExpression.ts b/tests/cases/conformance/es6/templates/templateStringInDeleteExpression.ts
new file mode 100644
index 00000000000..f3af01582a5
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInDeleteExpression.ts
@@ -0,0 +1 @@
+delete `abc${0}abc`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInDeleteExpressionES6.ts b/tests/cases/conformance/es6/templates/templateStringInDeleteExpressionES6.ts
new file mode 100644
index 00000000000..cd81c11453a
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInDeleteExpressionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+delete `abc${0}abc`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInDivision.ts b/tests/cases/conformance/es6/templates/templateStringInDivision.ts
new file mode 100644
index 00000000000..9650f5e2455
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInDivision.ts
@@ -0,0 +1 @@
+var x = `abc${ 1 }def` / 1;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInEqualityChecks.ts b/tests/cases/conformance/es6/templates/templateStringInEqualityChecks.ts
new file mode 100644
index 00000000000..37b8511368e
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInEqualityChecks.ts
@@ -0,0 +1,4 @@
+var x = `abc${0}abc` === `abc` ||
+        `abc` !== `abc${0}abc` &&
+        `abc${0}abc` == "abc0abc" &&
+        "abc0abc" !== `abc${0}abc`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInEqualityChecksES6.ts b/tests/cases/conformance/es6/templates/templateStringInEqualityChecksES6.ts
new file mode 100644
index 00000000000..5254474b82b
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInEqualityChecksES6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+var x = `abc${0}abc` === `abc` ||
+        `abc` !== `abc${0}abc` &&
+        `abc${0}abc` == "abc0abc" &&
+        "abc0abc" !== `abc${0}abc`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInFunctionExpression.ts b/tests/cases/conformance/es6/templates/templateStringInFunctionExpression.ts
new file mode 100644
index 00000000000..5f0c5a4c96f
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInFunctionExpression.ts
@@ -0,0 +1,4 @@
+var x = function y() {
+    `abc${ 0 }def`
+    return `abc${ 0 }def`;
+};
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInFunctionExpressionES6.ts b/tests/cases/conformance/es6/templates/templateStringInFunctionExpressionES6.ts
new file mode 100644
index 00000000000..729ecbd0744
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInFunctionExpressionES6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+var x = function y() {
+    `abc${ 0 }def`
+    return `abc${ 0 }def`;
+};
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts b/tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts
new file mode 100644
index 00000000000..628ba29081b
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInFunctionParameterType.ts
@@ -0,0 +1,5 @@
+function f(`hello`);
+function f(x: string);
+function f(x: string) {
+    return x;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts b/tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts
new file mode 100644
index 00000000000..03fb0a7de88
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInFunctionParameterTypeES6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+function f(`hello`);
+function f(x: string);
+function f(x: string) {
+    return x;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInInOperator.ts b/tests/cases/conformance/es6/templates/templateStringInInOperator.ts
new file mode 100644
index 00000000000..cc50b275144
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInInOperator.ts
@@ -0,0 +1 @@
+var x = `${ "hi" }` in { hi: 10, hello: 20};
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInInOperatorES6.ts b/tests/cases/conformance/es6/templates/templateStringInInOperatorES6.ts
new file mode 100644
index 00000000000..5a23a0b4e3f
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInInOperatorES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `${ "hi" }` in { hi: 10, hello: 20};
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInIndexExpression.ts b/tests/cases/conformance/es6/templates/templateStringInIndexExpression.ts
new file mode 100644
index 00000000000..792e92a4dc7
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInIndexExpression.ts
@@ -0,0 +1 @@
+`abc${0}abc`[`0`];
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInIndexExpressionES6.ts b/tests/cases/conformance/es6/templates/templateStringInIndexExpressionES6.ts
new file mode 100644
index 00000000000..6a431b3bb13
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInIndexExpressionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+`abc${0}abc`[`0`];
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInInstanceOf.ts b/tests/cases/conformance/es6/templates/templateStringInInstanceOf.ts
new file mode 100644
index 00000000000..12ec4e7baf7
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInInstanceOf.ts
@@ -0,0 +1 @@
+var x = `abc${ 0 }def` instanceof String;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInInstanceOfES6.ts b/tests/cases/conformance/es6/templates/templateStringInInstanceOfES6.ts
new file mode 100644
index 00000000000..6afe22b74b6
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInInstanceOfES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ 0 }def` instanceof String;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInModuleName.ts b/tests/cases/conformance/es6/templates/templateStringInModuleName.ts
new file mode 100644
index 00000000000..8ed5038ffbf
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInModuleName.ts
@@ -0,0 +1,5 @@
+declare module `M1` {
+}
+
+declare module `M${2}` {
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts b/tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts
new file mode 100644
index 00000000000..44d3999febc
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInModuleNameES6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+declare module `M1` {
+}
+
+declare module `M${2}` {
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInModulo.ts b/tests/cases/conformance/es6/templates/templateStringInModulo.ts
new file mode 100644
index 00000000000..69d7faeda75
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInModulo.ts
@@ -0,0 +1 @@
+var x = 1 % `abc${ 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInModuloES6.ts b/tests/cases/conformance/es6/templates/templateStringInModuloES6.ts
new file mode 100644
index 00000000000..0d05c3570ba
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInModuloES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = 1 % `abc${ 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInMultiplication.ts b/tests/cases/conformance/es6/templates/templateStringInMultiplication.ts
new file mode 100644
index 00000000000..a8ba70bf102
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInMultiplication.ts
@@ -0,0 +1 @@
+var x = 1 * `abc${ 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInMultiplicationES6.ts b/tests/cases/conformance/es6/templates/templateStringInMultiplicationES6.ts
new file mode 100644
index 00000000000..c0ffa96d98c
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInMultiplicationES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = 1 * `abc${ 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInNewOperator.ts b/tests/cases/conformance/es6/templates/templateStringInNewOperator.ts
new file mode 100644
index 00000000000..f53dd3023d2
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInNewOperator.ts
@@ -0,0 +1 @@
+var x = new `abc${ 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInNewOperatorES6.ts b/tests/cases/conformance/es6/templates/templateStringInNewOperatorES6.ts
new file mode 100644
index 00000000000..aad17d31ae2
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInNewOperatorES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = new `abc${ 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts b/tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts
new file mode 100644
index 00000000000..e1ce34a20db
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts
@@ -0,0 +1,4 @@
+var x = {
+    a: `abc${ 123 }def`,
+    `b`: 321
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts b/tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts
new file mode 100644
index 00000000000..9ef032e4c88
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+var x = {
+    a: `abc${ 123 }def`,
+    `b`: 321
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInParentheses.ts b/tests/cases/conformance/es6/templates/templateStringInParentheses.ts
new file mode 100644
index 00000000000..de5948e2bc2
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInParentheses.ts
@@ -0,0 +1 @@
+var x = (`abc${0}abc`);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInParenthesesES6.ts b/tests/cases/conformance/es6/templates/templateStringInParenthesesES6.ts
new file mode 100644
index 00000000000..856392e7c14
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInParenthesesES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = (`abc${0}abc`);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInPropertyAssignment.ts b/tests/cases/conformance/es6/templates/templateStringInPropertyAssignment.ts
new file mode 100644
index 00000000000..3b362d942d9
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInPropertyAssignment.ts
@@ -0,0 +1,3 @@
+var x = {
+    a: `abc${ 123 }def${ 456 }ghi`
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInPropertyAssignmentES6.ts b/tests/cases/conformance/es6/templates/templateStringInPropertyAssignmentES6.ts
new file mode 100644
index 00000000000..6a99df5b34f
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInPropertyAssignmentES6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+var x = {
+    a: `abc${ 123 }def${ 456 }ghi`
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts b/tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts
new file mode 100644
index 00000000000..c3c4ca3ecb5
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts
@@ -0,0 +1,3 @@
+var x = {
+    `a`: 321
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts b/tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts
new file mode 100644
index 00000000000..d21ab30888f
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts
@@ -0,0 +1,3 @@
+var x = {
+    `abc${ 123 }def${ 456 }ghi`: 321
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts b/tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts
new file mode 100644
index 00000000000..9bb814d32cf
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+var x = {
+    `a`: 321
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts b/tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts
new file mode 100644
index 00000000000..7179f217caa
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+var x = {
+    `abc${ 123 }def${ 456 }ghi`: 321
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInSwitchAndCase.ts b/tests/cases/conformance/es6/templates/templateStringInSwitchAndCase.ts
new file mode 100644
index 00000000000..3b88a23c298
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInSwitchAndCase.ts
@@ -0,0 +1,6 @@
+switch (`abc${0}abc`) {
+    case `abc`:
+    case `123`:
+    case `abc${0}abc`:
+        `def${1}def`;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInSwitchAndCaseES6.ts b/tests/cases/conformance/es6/templates/templateStringInSwitchAndCaseES6.ts
new file mode 100644
index 00000000000..c1872816ccc
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInSwitchAndCaseES6.ts
@@ -0,0 +1,7 @@
+// @target: ES6
+switch (`abc${0}abc`) {
+    case `abc`:
+    case `123`:
+    case `abc${0}abc`:
+        `def${1}def`;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInTypeAssertion.ts b/tests/cases/conformance/es6/templates/templateStringInTypeAssertion.ts
new file mode 100644
index 00000000000..b5a29156f56
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInTypeAssertion.ts
@@ -0,0 +1 @@
+var x = <any>`abc${ 123 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInTypeAssertionES6.ts b/tests/cases/conformance/es6/templates/templateStringInTypeAssertionES6.ts
new file mode 100644
index 00000000000..e1fc20728a0
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInTypeAssertionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = <any>`abc${ 123 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInTypeOf.ts b/tests/cases/conformance/es6/templates/templateStringInTypeOf.ts
new file mode 100644
index 00000000000..da69e86c0b7
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInTypeOf.ts
@@ -0,0 +1 @@
+var x = typeof `abc${ 123 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInTypeOfES6.ts b/tests/cases/conformance/es6/templates/templateStringInTypeOfES6.ts
new file mode 100644
index 00000000000..a5f96923daa
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInTypeOfES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = typeof `abc${ 123 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInUnaryPlus.ts b/tests/cases/conformance/es6/templates/templateStringInUnaryPlus.ts
new file mode 100644
index 00000000000..3f9b667d51d
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInUnaryPlus.ts
@@ -0,0 +1 @@
+var x = +`abc${ 123 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInUnaryPlusES6.ts b/tests/cases/conformance/es6/templates/templateStringInUnaryPlusES6.ts
new file mode 100644
index 00000000000..4baba61696d
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInUnaryPlusES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = +`abc${ 123 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInWhile.ts b/tests/cases/conformance/es6/templates/templateStringInWhile.ts
new file mode 100644
index 00000000000..8baeaeadc97
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInWhile.ts
@@ -0,0 +1,3 @@
+while (`abc${0}abc`) {
+    `def${1}def`;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInWhileES6.ts b/tests/cases/conformance/es6/templates/templateStringInWhileES6.ts
new file mode 100644
index 00000000000..d30cdb4ec2a
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInWhileES6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+while (`abc${0}abc`) {
+    `def${1}def`;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts b/tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts
new file mode 100644
index 00000000000..4a80e452251
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts
@@ -0,0 +1,4 @@
+function* gen {
+    // Once this is supported, the inner expression does not need to be parenthesized.
+    var x = yield `abc${ x }def`;
+}
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedAddition.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedAddition.ts
new file mode 100644
index 00000000000..73f9c6b6b84
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedAddition.ts
@@ -0,0 +1 @@
+var x = `abc${ 10 + 10 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedAdditionES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedAdditionES6.ts
new file mode 100644
index 00000000000..12cda7856fa
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedAdditionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ 10 + 10 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArray.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArray.ts
new file mode 100644
index 00000000000..77ea762070b
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArray.ts
@@ -0,0 +1 @@
+var x = `abc${ [1,2,3] }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrayES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrayES6.ts
new file mode 100644
index 00000000000..2be90b5abfa
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrayES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ [1,2,3] }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunction.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunction.ts
new file mode 100644
index 00000000000..8d879732c79
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunction.ts
@@ -0,0 +1 @@
+var x = `abc${ x => x }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunctionES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunctionES6.ts
new file mode 100644
index 00000000000..946bd41470f
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunctionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ x => x }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedComments.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedComments.ts
new file mode 100644
index 00000000000..2cb295bbfeb
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedComments.ts
@@ -0,0 +1,12 @@
+`head${ // single line comment
+10
+}
+middle${
+/* Multi-
+ * line
+ * comment
+ */
+ 20
+ // closing comment
+}
+tail`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedCommentsES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedCommentsES6.ts
new file mode 100644
index 00000000000..2cb295bbfeb
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedCommentsES6.ts
@@ -0,0 +1,12 @@
+`head${ // single line comment
+10
+}
+middle${
+/* Multi-
+ * line
+ * comment
+ */
+ 20
+ // closing comment
+}
+tail`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditional.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditional.ts
new file mode 100644
index 00000000000..6c70bbc9b04
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditional.ts
@@ -0,0 +1 @@
+var x = `abc${ true ? false : " " }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditionalES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditionalES6.ts
new file mode 100644
index 00000000000..b1366210a28
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedConditionalES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ true ? false : " " }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivision.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivision.ts
new file mode 100644
index 00000000000..82ea537dc13
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivision.ts
@@ -0,0 +1 @@
+var x = `abc${ 1 / 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivisionES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivisionES6.ts
new file mode 100644
index 00000000000..04f3740e3ae
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedDivisionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ 1 / 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpression.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpression.ts
new file mode 100644
index 00000000000..05c69d962e5
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpression.ts
@@ -0,0 +1 @@
+var x = `abc${ function y() { return y; } }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpressionES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpressionES6.ts
new file mode 100644
index 00000000000..3aab00817ee
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpressionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ function y() { return y; } }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperator.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperator.ts
new file mode 100644
index 00000000000..0e823e0ee11
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperator.ts
@@ -0,0 +1 @@
+var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperatorES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperatorES6.ts
new file mode 100644
index 00000000000..c678d542467
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperatorES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOf.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOf.ts
new file mode 100644
index 00000000000..b8cd9ba5740
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOf.ts
@@ -0,0 +1 @@
+var x = `abc${ "hello" instanceof String }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOfES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOfES6.ts
new file mode 100644
index 00000000000..a6598788b92
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOfES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ "hello" instanceof String }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedModulo.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedModulo.ts
new file mode 100644
index 00000000000..675627cb25d
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedModulo.ts
@@ -0,0 +1 @@
+var x = `abc${ 1 % 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedModuloES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedModuloES6.ts
new file mode 100644
index 00000000000..8b6d3ed7ef2
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedModuloES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ 1 % 1 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplication.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplication.ts
new file mode 100644
index 00000000000..09a99646fc8
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplication.ts
@@ -0,0 +1 @@
+var x = `abc${ 7 * 6 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplicationES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplicationES6.ts
new file mode 100644
index 00000000000..1378909e1c6
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedMultiplicationES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ 7 * 6 }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperator.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperator.ts
new file mode 100644
index 00000000000..0f2652f892b
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperator.ts
@@ -0,0 +1 @@
+var x = `abc${ new String("Hi") }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts
new file mode 100644
index 00000000000..4313531575a
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ new String("Hi") }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteral.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteral.ts
new file mode 100644
index 00000000000..bfdbb3d6a34
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteral.ts
@@ -0,0 +1 @@
+var x = `abc${ { x: 10, y: 20 } }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteralES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteralES6.ts
new file mode 100644
index 00000000000..9927f5fe95e
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteralES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ { x: 10, y: 20 } }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateString.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateString.ts
new file mode 100644
index 00000000000..4fc2778aa4f
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateString.ts
@@ -0,0 +1 @@
+var x = `123${ `456 ${ " | " } 654` }321 123${ `456 ${ " | " } 654` }321`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateStringES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateStringES6.ts
new file mode 100644
index 00000000000..4f8063ab03b
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTemplateStringES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `123${ `456 ${ " | " } 654` }321 123${ `456 ${ " | " } 654` }321`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAddition.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAddition.ts
new file mode 100644
index 00000000000..90a0e3561a3
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAddition.ts
@@ -0,0 +1 @@
+var x = `abc${ <any>(10 + 10) }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAdditionES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAdditionES6.ts
new file mode 100644
index 00000000000..9c0537b6489
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeAssertionOnAdditionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ <any>(10 + 10) }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperator.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperator.ts
new file mode 100644
index 00000000000..1a93e586bda
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperator.ts
@@ -0,0 +1 @@
+var x = `abc${ typeof "hi" }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperatorES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperatorES6.ts
new file mode 100644
index 00000000000..534cd667f43
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedTypeOfOperatorES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ typeof "hi" }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlus.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlus.ts
new file mode 100644
index 00000000000..f97583812e4
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlus.ts
@@ -0,0 +1 @@
+var x = `abc${ +Infinity }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlusES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlusES6.ts
new file mode 100644
index 00000000000..7b724dba579
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlusES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+var x = `abc${ +Infinity }def`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts
new file mode 100644
index 00000000000..cbf7f272581
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts
@@ -0,0 +1,4 @@
+function* gen {
+    // Once this is supported, yield *must* be parenthesized.
+    var x = `abc${ yield 10 }def`;
+}
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts
new file mode 100644
index 00000000000..5a7409aef79
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+function* gen() {
+    // Once this is supported, yield *must* be parenthesized.
+    var x = `abc${ yield 10 }def`;
+}
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts
new file mode 100644
index 00000000000..11dca4caf77
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts
@@ -0,0 +1,23 @@
+var a = ``;
+
+var b = `${ 0 }`;
+
+var c = `1${ 0 }`;
+
+var d = `${ 0 }2`;
+
+var e = `1${ 0 }2`;
+
+var f = `${ 0 }${ 0 }`;
+
+var g = `1${ 0 }${ 0 }`;
+
+var h = `${ 0 }2${ 0 }`;
+
+var i = `1${ 0 }2${ 0 }`;
+
+var j = `${ 0 }${ 0 }3`;
+
+var k = `1${ 0 }${ 0 }3`;
+
+var l = `1${ 0 }2${ 0 }3`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts
new file mode 100644
index 00000000000..183da57dd45
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts
@@ -0,0 +1,24 @@
+// @target: ES6
+var a = ``;
+
+var b = `${ 0 }`;
+
+var c = `1${ 0 }`;
+
+var d = `${ 0 }2`;
+
+var e = `1${ 0 }2`;
+
+var f = `${ 0 }${ 0 }`;
+
+var g = `1${ 0 }${ 0 }`;
+
+var h = `${ 0 }2${ 0 }`;
+
+var i = `1${ 0 }2${ 0 }`;
+
+var j = `${ 0 }${ 0 }3`;
+
+var k = `1${ 0 }${ 0 }3`;
+
+var l = `1${ 0 }2${ 0 }3`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortion.ts b/tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortion.ts
new file mode 100644
index 00000000000..9101c8e3e6b
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortion.ts
@@ -0,0 +1 @@
+` /**head  ${ 10 } // still middle  ${ 20 } /* still tail `
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortionES6.ts b/tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortionES6.ts
new file mode 100644
index 00000000000..cb7f76540cc
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithOpenCommentInStringPortionES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+` /**head  ${ 10 } // still middle  ${ 20 } /* still tail `
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithPropertyAccess.ts b/tests/cases/conformance/es6/templates/templateStringWithPropertyAccess.ts
new file mode 100644
index 00000000000..87682fff572
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithPropertyAccess.ts
@@ -0,0 +1 @@
+`abc${0}abc`.indexOf(`abc`);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/templateStringWithPropertyAccessES6.ts b/tests/cases/conformance/es6/templates/templateStringWithPropertyAccessES6.ts
new file mode 100644
index 00000000000..261ea75bde6
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/templateStringWithPropertyAccessES6.ts
@@ -0,0 +1,2 @@
+// @target: ES6
+`abc${0}abc`.indexOf(`abc`);
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionListInTemplateLiteralParts1.ts b/tests/cases/fourslash/completionListInTemplateLiteralParts1.ts
new file mode 100644
index 00000000000..a71584bdbdd
--- /dev/null
+++ b/tests/cases/fourslash/completionListInTemplateLiteralParts1.ts
@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts" />
+
+/////*0*/`  $ { ${/*1*/ 10/*2*/ + 1.1/*3*/ /*4*/} 12312`/*5*/
+////
+/////*6*/`asdasd${/*7*/ 2 + 1.1 /*8*/} 12312 {
+
+test.markers().forEach(marker => {
+    goTo.position(marker.position);
+
+    verify.completionListItemsCountIsGreaterThan(0)
+}}
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionListInTemplateLiteralPartsNegatives1.ts b/tests/cases/fourslash/completionListInTemplateLiteralPartsNegatives1.ts
new file mode 100644
index 00000000000..1624192057b
--- /dev/null
+++ b/tests/cases/fourslash/completionListInTemplateLiteralPartsNegatives1.ts
@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts" />
+
+////`/*0*/ /*1*/$ /*2*/{ /*3*/$/*4*/{ 10 + 1.1 }/*5*/ 12312/*6*/`
+////
+////`asdasd$/*7*/{ 2 + 1.1 }/*8*/ 12312 /*9*/{/*10*/
+
+test.markers().forEach(marker => {
+    goTo.position(marker.position);
+
+    verify.completionListIsEmpty()
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/semanticClassificationInTemplateExpressions.ts b/tests/cases/fourslash/semanticClassificationInTemplateExpressions.ts
new file mode 100644
index 00000000000..19f6d1062cb
--- /dev/null
+++ b/tests/cases/fourslash/semanticClassificationInTemplateExpressions.ts
@@ -0,0 +1,21 @@
+/// <reference path="fourslash.ts"/>
+
+////module /*0*/M {
+////    export class /*1*/C {
+////        static x;
+////    }
+////    export enum /*2*/E {
+////        E1 = 0
+////    }
+////}
+////`abcd${ /*3*/M./*4*/C.x + /*5*/M./*6*/E.E1}efg`
+
+var c = classification;
+verify.semanticClassificationsAre(
+    c.moduleName("M", test.marker("0").position),
+    c.className("C", test.marker("1").position),
+    c.enumName("E", test.marker("2").position),
+    c.moduleName("M", test.marker("3").position),
+    c.className("C", test.marker("4").position),
+    c.moduleName("M", test.marker("5").position),
+    c.enumName("E", test.marker("6").position));
diff --git a/tests/cases/fourslash/syntacticClassificationsTemplates1.ts b/tests/cases/fourslash/syntacticClassificationsTemplates1.ts
new file mode 100644
index 00000000000..4c79c047c81
--- /dev/null
+++ b/tests/cases/fourslash/syntacticClassificationsTemplates1.ts
@@ -0,0 +1,15 @@
+/// <reference path="fourslash.ts"/>
+
+////var v = 10e0;
+////var x = {
+////    p1: `hello world`,
+////    p2: `goodbye ${0} cruel ${0} world`,
+////};
+
+var c = classification;
+verify.syntacticClassificationsAre(
+    c.keyword("var"), c.text("v"), c.operator("="), c.numericLiteral("10e0"), c.punctuation(";"),
+    c.keyword("var"), c.text("x"), c.operator("="), c.punctuation("{"),
+    c.text("p1"), c.punctuation(":"), c.stringLiteral("`hello world`"), c.punctuation(","),
+    c.text("p2"), c.punctuation(":"), c.stringLiteral("`goodbye ${"), c.numericLiteral("0"), c.stringLiteral("} cruel ${"), c.numericLiteral("0"), c.stringLiteral("} world`"), c.punctuation(","),
+    c.punctuation("}"), c.punctuation(";"));
\ No newline at end of file
diff --git a/tests/cases/fourslash/syntacticClassificationsTemplates2.ts b/tests/cases/fourslash/syntacticClassificationsTemplates2.ts
new file mode 100644
index 00000000000..19bad4b54a8
--- /dev/null
+++ b/tests/cases/fourslash/syntacticClassificationsTemplates2.ts
@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts"/>
+
+////var tiredOfCanonicalExamples =
+////`goodbye "${ `hello world` }" 
+////and ${ `good${ " " }riddance` }`;
+
+var c = classification;
+verify.syntacticClassificationsAre(
+    c.keyword("var"), c.text("tiredOfCanonicalExamples"), c.operator("="),
+    c.stringLiteral("`goodbye \"${"), c.stringLiteral("`hello world`"),
+    c.stringLiteral("}\" \nand ${"), c.stringLiteral("`good${"), c.stringLiteral("\" \""), c.stringLiteral("}riddance`"), c.stringLiteral("}`"), c.punctuation(";"));
\ No newline at end of file