diff --git a/src/services/resources/diagnosticCode.generated.ts b/src/services/resources/diagnosticCode.generated.ts index 26df20b428d92..838879b55bcf8 100644 --- a/src/services/resources/diagnosticCode.generated.ts +++ b/src/services/resources/diagnosticCode.generated.ts @@ -13,7 +13,6 @@ module TypeScript { Automatic_semicolon_insertion_not_allowed: "Automatic semicolon insertion not allowed.", Unexpected_token_0_expected: "Unexpected token; '{0}' expected.", Trailing_comma_not_allowed: "Trailing comma not allowed.", - AsteriskSlash_expected: "'*/' expected.", public_or_private_modifier_must_precede_static: "'public' or 'private' modifier must precede 'static'.", Unexpected_token: "Unexpected token.", Catch_clause_parameter_cannot_have_a_type_annotation: "Catch clause parameter cannot have a type annotation.", @@ -95,6 +94,7 @@ module TypeScript { return_statement_must_be_contained_within_a_function_body: "'return' statement must be contained within a function body.", Expression_expected: "Expression expected.", Type_expected: "Type expected.", + Template_literal_cannot_be_used_as_an_element_name: "Template literal cannot be used as an element name.", Duplicate_identifier_0: "Duplicate identifier '{0}'.", The_name_0_does_not_exist_in_the_current_scope: "The name '{0}' does not exist in the current scope.", The_name_0_does_not_refer_to_a_value: "The name '{0}' does not refer to a value.", diff --git a/src/services/resources/diagnosticInformationMap.generated.ts b/src/services/resources/diagnosticInformationMap.generated.ts index 8d3bc73486e71..6bf01f5873a93 100644 --- a/src/services/resources/diagnosticInformationMap.generated.ts +++ b/src/services/resources/diagnosticInformationMap.generated.ts @@ -96,6 +96,7 @@ module TypeScript { "'return' statement must be contained within a function body.": { "code": 1108, "category": DiagnosticCategory.Error }, "Expression expected.": { "code": 1109, "category": DiagnosticCategory.Error }, "Type expected.": { "code": 1110, "category": DiagnosticCategory.Error }, + "Template literal cannot be used as an element name.": { "code": 1111, "category": DiagnosticCategory.Error }, "Duplicate identifier '{0}'.": { "code": 2000, "category": DiagnosticCategory.Error }, "The name '{0}' does not exist in the current scope.": { "code": 2001, "category": DiagnosticCategory.Error }, "The name '{0}' does not refer to a value.": { "code": 2002, "category": DiagnosticCategory.Error }, diff --git a/src/services/resources/diagnosticMessages.json b/src/services/resources/diagnosticMessages.json index bbca8b3f9cef6..95e7f109edfc5 100644 --- a/src/services/resources/diagnosticMessages.json +++ b/src/services/resources/diagnosticMessages.json @@ -47,10 +47,6 @@ "category": "Error", "code": 1009 }, - "'*/' expected.": { - "category": "Error", - "code": 1010 - }, "'public' or 'private' modifier must precede 'static'.": { "category": "Error", "code": 1011 @@ -375,6 +371,10 @@ "category": "Error", "code": 1110 }, + "Template literal cannot be used as an element name.": { + "category": "Error", + "code": 1111 + }, "Duplicate identifier '{0}'.": { "category": "Error", "code": 2000 diff --git a/src/services/syntax/SyntaxGenerator.js b/src/services/syntax/SyntaxGenerator.js index adb64b3942c4c..0c3dd9e5b38f6 100644 --- a/src/services/syntax/SyntaxGenerator.js +++ b/src/services/syntax/SyntaxGenerator.js @@ -422,199 +422,206 @@ var TypeScript; SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 10] = "RegularExpressionLiteral"; SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral"; SyntaxKind[SyntaxKind["StringLiteral"] = 12] = "StringLiteral"; - SyntaxKind[SyntaxKind["BreakKeyword"] = 13] = "BreakKeyword"; - SyntaxKind[SyntaxKind["CaseKeyword"] = 14] = "CaseKeyword"; - SyntaxKind[SyntaxKind["CatchKeyword"] = 15] = "CatchKeyword"; - SyntaxKind[SyntaxKind["ContinueKeyword"] = 16] = "ContinueKeyword"; - SyntaxKind[SyntaxKind["DebuggerKeyword"] = 17] = "DebuggerKeyword"; - SyntaxKind[SyntaxKind["DefaultKeyword"] = 18] = "DefaultKeyword"; - SyntaxKind[SyntaxKind["DeleteKeyword"] = 19] = "DeleteKeyword"; - SyntaxKind[SyntaxKind["DoKeyword"] = 20] = "DoKeyword"; - SyntaxKind[SyntaxKind["ElseKeyword"] = 21] = "ElseKeyword"; - SyntaxKind[SyntaxKind["FalseKeyword"] = 22] = "FalseKeyword"; - SyntaxKind[SyntaxKind["FinallyKeyword"] = 23] = "FinallyKeyword"; - SyntaxKind[SyntaxKind["ForKeyword"] = 24] = "ForKeyword"; - SyntaxKind[SyntaxKind["FunctionKeyword"] = 25] = "FunctionKeyword"; - SyntaxKind[SyntaxKind["IfKeyword"] = 26] = "IfKeyword"; - SyntaxKind[SyntaxKind["InKeyword"] = 27] = "InKeyword"; - SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 28] = "InstanceOfKeyword"; - SyntaxKind[SyntaxKind["NewKeyword"] = 29] = "NewKeyword"; - SyntaxKind[SyntaxKind["NullKeyword"] = 30] = "NullKeyword"; - SyntaxKind[SyntaxKind["ReturnKeyword"] = 31] = "ReturnKeyword"; - SyntaxKind[SyntaxKind["SwitchKeyword"] = 32] = "SwitchKeyword"; - SyntaxKind[SyntaxKind["ThisKeyword"] = 33] = "ThisKeyword"; - SyntaxKind[SyntaxKind["ThrowKeyword"] = 34] = "ThrowKeyword"; - SyntaxKind[SyntaxKind["TrueKeyword"] = 35] = "TrueKeyword"; - SyntaxKind[SyntaxKind["TryKeyword"] = 36] = "TryKeyword"; - SyntaxKind[SyntaxKind["TypeOfKeyword"] = 37] = "TypeOfKeyword"; - SyntaxKind[SyntaxKind["VarKeyword"] = 38] = "VarKeyword"; - SyntaxKind[SyntaxKind["VoidKeyword"] = 39] = "VoidKeyword"; - SyntaxKind[SyntaxKind["WhileKeyword"] = 40] = "WhileKeyword"; - SyntaxKind[SyntaxKind["WithKeyword"] = 41] = "WithKeyword"; - SyntaxKind[SyntaxKind["ClassKeyword"] = 42] = "ClassKeyword"; - SyntaxKind[SyntaxKind["ConstKeyword"] = 43] = "ConstKeyword"; - SyntaxKind[SyntaxKind["EnumKeyword"] = 44] = "EnumKeyword"; - SyntaxKind[SyntaxKind["ExportKeyword"] = 45] = "ExportKeyword"; - SyntaxKind[SyntaxKind["ExtendsKeyword"] = 46] = "ExtendsKeyword"; - SyntaxKind[SyntaxKind["ImportKeyword"] = 47] = "ImportKeyword"; - SyntaxKind[SyntaxKind["SuperKeyword"] = 48] = "SuperKeyword"; - SyntaxKind[SyntaxKind["ImplementsKeyword"] = 49] = "ImplementsKeyword"; - SyntaxKind[SyntaxKind["InterfaceKeyword"] = 50] = "InterfaceKeyword"; - SyntaxKind[SyntaxKind["LetKeyword"] = 51] = "LetKeyword"; - SyntaxKind[SyntaxKind["PackageKeyword"] = 52] = "PackageKeyword"; - SyntaxKind[SyntaxKind["PrivateKeyword"] = 53] = "PrivateKeyword"; - SyntaxKind[SyntaxKind["ProtectedKeyword"] = 54] = "ProtectedKeyword"; - SyntaxKind[SyntaxKind["PublicKeyword"] = 55] = "PublicKeyword"; - SyntaxKind[SyntaxKind["StaticKeyword"] = 56] = "StaticKeyword"; - SyntaxKind[SyntaxKind["YieldKeyword"] = 57] = "YieldKeyword"; - SyntaxKind[SyntaxKind["AnyKeyword"] = 58] = "AnyKeyword"; - SyntaxKind[SyntaxKind["BooleanKeyword"] = 59] = "BooleanKeyword"; - SyntaxKind[SyntaxKind["ConstructorKeyword"] = 60] = "ConstructorKeyword"; - SyntaxKind[SyntaxKind["DeclareKeyword"] = 61] = "DeclareKeyword"; - SyntaxKind[SyntaxKind["GetKeyword"] = 62] = "GetKeyword"; - SyntaxKind[SyntaxKind["ModuleKeyword"] = 63] = "ModuleKeyword"; - SyntaxKind[SyntaxKind["RequireKeyword"] = 64] = "RequireKeyword"; - SyntaxKind[SyntaxKind["NumberKeyword"] = 65] = "NumberKeyword"; - SyntaxKind[SyntaxKind["SetKeyword"] = 66] = "SetKeyword"; - SyntaxKind[SyntaxKind["StringKeyword"] = 67] = "StringKeyword"; - SyntaxKind[SyntaxKind["OpenBraceToken"] = 68] = "OpenBraceToken"; - SyntaxKind[SyntaxKind["CloseBraceToken"] = 69] = "CloseBraceToken"; - SyntaxKind[SyntaxKind["OpenParenToken"] = 70] = "OpenParenToken"; - SyntaxKind[SyntaxKind["CloseParenToken"] = 71] = "CloseParenToken"; - SyntaxKind[SyntaxKind["OpenBracketToken"] = 72] = "OpenBracketToken"; - SyntaxKind[SyntaxKind["CloseBracketToken"] = 73] = "CloseBracketToken"; - SyntaxKind[SyntaxKind["DotToken"] = 74] = "DotToken"; - SyntaxKind[SyntaxKind["DotDotDotToken"] = 75] = "DotDotDotToken"; - SyntaxKind[SyntaxKind["SemicolonToken"] = 76] = "SemicolonToken"; - SyntaxKind[SyntaxKind["CommaToken"] = 77] = "CommaToken"; - SyntaxKind[SyntaxKind["LessThanToken"] = 78] = "LessThanToken"; - SyntaxKind[SyntaxKind["GreaterThanToken"] = 79] = "GreaterThanToken"; - SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 80] = "LessThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 81] = "GreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 82] = "EqualsEqualsToken"; - SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 83] = "EqualsGreaterThanToken"; - SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 84] = "ExclamationEqualsToken"; - SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 85] = "EqualsEqualsEqualsToken"; - SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 86] = "ExclamationEqualsEqualsToken"; - SyntaxKind[SyntaxKind["PlusToken"] = 87] = "PlusToken"; - SyntaxKind[SyntaxKind["MinusToken"] = 88] = "MinusToken"; - SyntaxKind[SyntaxKind["AsteriskToken"] = 89] = "AsteriskToken"; - SyntaxKind[SyntaxKind["PercentToken"] = 90] = "PercentToken"; - SyntaxKind[SyntaxKind["PlusPlusToken"] = 91] = "PlusPlusToken"; - SyntaxKind[SyntaxKind["MinusMinusToken"] = 92] = "MinusMinusToken"; - SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 93] = "LessThanLessThanToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 94] = "GreaterThanGreaterThanToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 95] = "GreaterThanGreaterThanGreaterThanToken"; - SyntaxKind[SyntaxKind["AmpersandToken"] = 96] = "AmpersandToken"; - SyntaxKind[SyntaxKind["BarToken"] = 97] = "BarToken"; - SyntaxKind[SyntaxKind["CaretToken"] = 98] = "CaretToken"; - SyntaxKind[SyntaxKind["ExclamationToken"] = 99] = "ExclamationToken"; - SyntaxKind[SyntaxKind["TildeToken"] = 100] = "TildeToken"; - SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 101] = "AmpersandAmpersandToken"; - SyntaxKind[SyntaxKind["BarBarToken"] = 102] = "BarBarToken"; - SyntaxKind[SyntaxKind["QuestionToken"] = 103] = "QuestionToken"; - SyntaxKind[SyntaxKind["ColonToken"] = 104] = "ColonToken"; - SyntaxKind[SyntaxKind["EqualsToken"] = 105] = "EqualsToken"; - SyntaxKind[SyntaxKind["PlusEqualsToken"] = 106] = "PlusEqualsToken"; - SyntaxKind[SyntaxKind["MinusEqualsToken"] = 107] = "MinusEqualsToken"; - SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 108] = "AsteriskEqualsToken"; - SyntaxKind[SyntaxKind["PercentEqualsToken"] = 109] = "PercentEqualsToken"; - SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 110] = "LessThanLessThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 111] = "GreaterThanGreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 112] = "GreaterThanGreaterThanGreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 113] = "AmpersandEqualsToken"; - SyntaxKind[SyntaxKind["BarEqualsToken"] = 114] = "BarEqualsToken"; - SyntaxKind[SyntaxKind["CaretEqualsToken"] = 115] = "CaretEqualsToken"; - SyntaxKind[SyntaxKind["SlashToken"] = 116] = "SlashToken"; - SyntaxKind[SyntaxKind["SlashEqualsToken"] = 117] = "SlashEqualsToken"; - SyntaxKind[SyntaxKind["SourceUnit"] = 118] = "SourceUnit"; - SyntaxKind[SyntaxKind["QualifiedName"] = 119] = "QualifiedName"; - SyntaxKind[SyntaxKind["ObjectType"] = 120] = "ObjectType"; - SyntaxKind[SyntaxKind["FunctionType"] = 121] = "FunctionType"; - SyntaxKind[SyntaxKind["ArrayType"] = 122] = "ArrayType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 123] = "ConstructorType"; - SyntaxKind[SyntaxKind["GenericType"] = 124] = "GenericType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 125] = "TypeQuery"; - SyntaxKind[SyntaxKind["TupleType"] = 126] = "TupleType"; - SyntaxKind[SyntaxKind["UnionType"] = 127] = "UnionType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 128] = "ParenthesizedType"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 129] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 130] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 131] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 132] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 133] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 134] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 135] = "ExportAssignment"; - SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 136] = "MemberFunctionDeclaration"; - SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 137] = "MemberVariableDeclaration"; - SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 138] = "ConstructorDeclaration"; - SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 139] = "IndexMemberDeclaration"; - SyntaxKind[SyntaxKind["GetAccessor"] = 140] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 141] = "SetAccessor"; - SyntaxKind[SyntaxKind["PropertySignature"] = 142] = "PropertySignature"; - SyntaxKind[SyntaxKind["CallSignature"] = 143] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 144] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 145] = "IndexSignature"; - SyntaxKind[SyntaxKind["MethodSignature"] = 146] = "MethodSignature"; - SyntaxKind[SyntaxKind["Block"] = 147] = "Block"; - SyntaxKind[SyntaxKind["IfStatement"] = 148] = "IfStatement"; - SyntaxKind[SyntaxKind["VariableStatement"] = 149] = "VariableStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 150] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 151] = "ReturnStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 152] = "SwitchStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 153] = "BreakStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 154] = "ContinueStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 155] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 156] = "ForInStatement"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 157] = "EmptyStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 158] = "ThrowStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 159] = "WhileStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 160] = "TryStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 161] = "LabeledStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 162] = "DoStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 163] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 164] = "WithStatement"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 165] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 166] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 167] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 168] = "VoidExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 169] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 170] = "BinaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 171] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["MemberAccessExpression"] = 172] = "MemberAccessExpression"; - SyntaxKind[SyntaxKind["InvocationExpression"] = 173] = "InvocationExpression"; - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 174] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 175] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 176] = "ObjectCreationExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 177] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 178] = "ParenthesizedArrowFunctionExpression"; - SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 179] = "SimpleArrowFunctionExpression"; - SyntaxKind[SyntaxKind["CastExpression"] = 180] = "CastExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 181] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 182] = "FunctionExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 183] = "OmittedExpression"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 184] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarator"] = 185] = "VariableDeclarator"; - SyntaxKind[SyntaxKind["ArgumentList"] = 186] = "ArgumentList"; - SyntaxKind[SyntaxKind["ParameterList"] = 187] = "ParameterList"; - SyntaxKind[SyntaxKind["TypeArgumentList"] = 188] = "TypeArgumentList"; - SyntaxKind[SyntaxKind["TypeParameterList"] = 189] = "TypeParameterList"; - SyntaxKind[SyntaxKind["HeritageClause"] = 190] = "HeritageClause"; - SyntaxKind[SyntaxKind["EqualsValueClause"] = 191] = "EqualsValueClause"; - SyntaxKind[SyntaxKind["CaseSwitchClause"] = 192] = "CaseSwitchClause"; - SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 193] = "DefaultSwitchClause"; - SyntaxKind[SyntaxKind["ElseClause"] = 194] = "ElseClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 195] = "CatchClause"; - SyntaxKind[SyntaxKind["FinallyClause"] = 196] = "FinallyClause"; - SyntaxKind[SyntaxKind["TypeParameter"] = 197] = "TypeParameter"; - SyntaxKind[SyntaxKind["Constraint"] = 198] = "Constraint"; - SyntaxKind[SyntaxKind["SimplePropertyAssignment"] = 199] = "SimplePropertyAssignment"; - SyntaxKind[SyntaxKind["FunctionPropertyAssignment"] = 200] = "FunctionPropertyAssignment"; - SyntaxKind[SyntaxKind["Parameter"] = 201] = "Parameter"; - SyntaxKind[SyntaxKind["EnumElement"] = 202] = "EnumElement"; - SyntaxKind[SyntaxKind["TypeAnnotation"] = 203] = "TypeAnnotation"; - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 204] = "ExternalModuleReference"; - SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 205] = "ModuleNameModuleReference"; + SyntaxKind[SyntaxKind["NoSubstitutionTemplateToken"] = 13] = "NoSubstitutionTemplateToken"; + SyntaxKind[SyntaxKind["TemplateStartToken"] = 14] = "TemplateStartToken"; + SyntaxKind[SyntaxKind["TemplateMiddleToken"] = 15] = "TemplateMiddleToken"; + SyntaxKind[SyntaxKind["TemplateEndToken"] = 16] = "TemplateEndToken"; + SyntaxKind[SyntaxKind["BreakKeyword"] = 17] = "BreakKeyword"; + SyntaxKind[SyntaxKind["CaseKeyword"] = 18] = "CaseKeyword"; + SyntaxKind[SyntaxKind["CatchKeyword"] = 19] = "CatchKeyword"; + SyntaxKind[SyntaxKind["ContinueKeyword"] = 20] = "ContinueKeyword"; + SyntaxKind[SyntaxKind["DebuggerKeyword"] = 21] = "DebuggerKeyword"; + SyntaxKind[SyntaxKind["DefaultKeyword"] = 22] = "DefaultKeyword"; + SyntaxKind[SyntaxKind["DeleteKeyword"] = 23] = "DeleteKeyword"; + SyntaxKind[SyntaxKind["DoKeyword"] = 24] = "DoKeyword"; + SyntaxKind[SyntaxKind["ElseKeyword"] = 25] = "ElseKeyword"; + SyntaxKind[SyntaxKind["FalseKeyword"] = 26] = "FalseKeyword"; + SyntaxKind[SyntaxKind["FinallyKeyword"] = 27] = "FinallyKeyword"; + SyntaxKind[SyntaxKind["ForKeyword"] = 28] = "ForKeyword"; + SyntaxKind[SyntaxKind["FunctionKeyword"] = 29] = "FunctionKeyword"; + SyntaxKind[SyntaxKind["IfKeyword"] = 30] = "IfKeyword"; + SyntaxKind[SyntaxKind["InKeyword"] = 31] = "InKeyword"; + SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 32] = "InstanceOfKeyword"; + SyntaxKind[SyntaxKind["NewKeyword"] = 33] = "NewKeyword"; + SyntaxKind[SyntaxKind["NullKeyword"] = 34] = "NullKeyword"; + SyntaxKind[SyntaxKind["ReturnKeyword"] = 35] = "ReturnKeyword"; + SyntaxKind[SyntaxKind["SwitchKeyword"] = 36] = "SwitchKeyword"; + SyntaxKind[SyntaxKind["ThisKeyword"] = 37] = "ThisKeyword"; + SyntaxKind[SyntaxKind["ThrowKeyword"] = 38] = "ThrowKeyword"; + SyntaxKind[SyntaxKind["TrueKeyword"] = 39] = "TrueKeyword"; + SyntaxKind[SyntaxKind["TryKeyword"] = 40] = "TryKeyword"; + SyntaxKind[SyntaxKind["TypeOfKeyword"] = 41] = "TypeOfKeyword"; + SyntaxKind[SyntaxKind["VarKeyword"] = 42] = "VarKeyword"; + SyntaxKind[SyntaxKind["VoidKeyword"] = 43] = "VoidKeyword"; + SyntaxKind[SyntaxKind["WhileKeyword"] = 44] = "WhileKeyword"; + SyntaxKind[SyntaxKind["WithKeyword"] = 45] = "WithKeyword"; + SyntaxKind[SyntaxKind["ClassKeyword"] = 46] = "ClassKeyword"; + SyntaxKind[SyntaxKind["ConstKeyword"] = 47] = "ConstKeyword"; + SyntaxKind[SyntaxKind["EnumKeyword"] = 48] = "EnumKeyword"; + SyntaxKind[SyntaxKind["ExportKeyword"] = 49] = "ExportKeyword"; + SyntaxKind[SyntaxKind["ExtendsKeyword"] = 50] = "ExtendsKeyword"; + SyntaxKind[SyntaxKind["ImportKeyword"] = 51] = "ImportKeyword"; + SyntaxKind[SyntaxKind["SuperKeyword"] = 52] = "SuperKeyword"; + SyntaxKind[SyntaxKind["ImplementsKeyword"] = 53] = "ImplementsKeyword"; + SyntaxKind[SyntaxKind["InterfaceKeyword"] = 54] = "InterfaceKeyword"; + SyntaxKind[SyntaxKind["LetKeyword"] = 55] = "LetKeyword"; + SyntaxKind[SyntaxKind["PackageKeyword"] = 56] = "PackageKeyword"; + SyntaxKind[SyntaxKind["PrivateKeyword"] = 57] = "PrivateKeyword"; + SyntaxKind[SyntaxKind["ProtectedKeyword"] = 58] = "ProtectedKeyword"; + SyntaxKind[SyntaxKind["PublicKeyword"] = 59] = "PublicKeyword"; + SyntaxKind[SyntaxKind["StaticKeyword"] = 60] = "StaticKeyword"; + SyntaxKind[SyntaxKind["YieldKeyword"] = 61] = "YieldKeyword"; + SyntaxKind[SyntaxKind["AnyKeyword"] = 62] = "AnyKeyword"; + SyntaxKind[SyntaxKind["BooleanKeyword"] = 63] = "BooleanKeyword"; + SyntaxKind[SyntaxKind["ConstructorKeyword"] = 64] = "ConstructorKeyword"; + SyntaxKind[SyntaxKind["DeclareKeyword"] = 65] = "DeclareKeyword"; + SyntaxKind[SyntaxKind["GetKeyword"] = 66] = "GetKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 67] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 68] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 69] = "NumberKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 70] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 71] = "StringKeyword"; + SyntaxKind[SyntaxKind["OpenBraceToken"] = 72] = "OpenBraceToken"; + SyntaxKind[SyntaxKind["CloseBraceToken"] = 73] = "CloseBraceToken"; + SyntaxKind[SyntaxKind["OpenParenToken"] = 74] = "OpenParenToken"; + SyntaxKind[SyntaxKind["CloseParenToken"] = 75] = "CloseParenToken"; + SyntaxKind[SyntaxKind["OpenBracketToken"] = 76] = "OpenBracketToken"; + SyntaxKind[SyntaxKind["CloseBracketToken"] = 77] = "CloseBracketToken"; + SyntaxKind[SyntaxKind["DotToken"] = 78] = "DotToken"; + SyntaxKind[SyntaxKind["DotDotDotToken"] = 79] = "DotDotDotToken"; + SyntaxKind[SyntaxKind["SemicolonToken"] = 80] = "SemicolonToken"; + SyntaxKind[SyntaxKind["CommaToken"] = 81] = "CommaToken"; + SyntaxKind[SyntaxKind["LessThanToken"] = 82] = "LessThanToken"; + SyntaxKind[SyntaxKind["GreaterThanToken"] = 83] = "GreaterThanToken"; + SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 84] = "LessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 85] = "GreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 86] = "EqualsEqualsToken"; + SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 87] = "EqualsGreaterThanToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 88] = "ExclamationEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 89] = "EqualsEqualsEqualsToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 90] = "ExclamationEqualsEqualsToken"; + SyntaxKind[SyntaxKind["PlusToken"] = 91] = "PlusToken"; + SyntaxKind[SyntaxKind["MinusToken"] = 92] = "MinusToken"; + SyntaxKind[SyntaxKind["AsteriskToken"] = 93] = "AsteriskToken"; + SyntaxKind[SyntaxKind["PercentToken"] = 94] = "PercentToken"; + SyntaxKind[SyntaxKind["PlusPlusToken"] = 95] = "PlusPlusToken"; + SyntaxKind[SyntaxKind["MinusMinusToken"] = 96] = "MinusMinusToken"; + SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 97] = "LessThanLessThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 98] = "GreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 99] = "GreaterThanGreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["AmpersandToken"] = 100] = "AmpersandToken"; + SyntaxKind[SyntaxKind["BarToken"] = 101] = "BarToken"; + SyntaxKind[SyntaxKind["CaretToken"] = 102] = "CaretToken"; + SyntaxKind[SyntaxKind["ExclamationToken"] = 103] = "ExclamationToken"; + SyntaxKind[SyntaxKind["TildeToken"] = 104] = "TildeToken"; + SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 105] = "AmpersandAmpersandToken"; + SyntaxKind[SyntaxKind["BarBarToken"] = 106] = "BarBarToken"; + SyntaxKind[SyntaxKind["QuestionToken"] = 107] = "QuestionToken"; + SyntaxKind[SyntaxKind["ColonToken"] = 108] = "ColonToken"; + SyntaxKind[SyntaxKind["EqualsToken"] = 109] = "EqualsToken"; + SyntaxKind[SyntaxKind["PlusEqualsToken"] = 110] = "PlusEqualsToken"; + SyntaxKind[SyntaxKind["MinusEqualsToken"] = 111] = "MinusEqualsToken"; + SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 112] = "AsteriskEqualsToken"; + SyntaxKind[SyntaxKind["PercentEqualsToken"] = 113] = "PercentEqualsToken"; + SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 114] = "LessThanLessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 115] = "GreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 116] = "GreaterThanGreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 117] = "AmpersandEqualsToken"; + SyntaxKind[SyntaxKind["BarEqualsToken"] = 118] = "BarEqualsToken"; + SyntaxKind[SyntaxKind["CaretEqualsToken"] = 119] = "CaretEqualsToken"; + SyntaxKind[SyntaxKind["SlashToken"] = 120] = "SlashToken"; + SyntaxKind[SyntaxKind["SlashEqualsToken"] = 121] = "SlashEqualsToken"; + SyntaxKind[SyntaxKind["SourceUnit"] = 122] = "SourceUnit"; + SyntaxKind[SyntaxKind["QualifiedName"] = 123] = "QualifiedName"; + SyntaxKind[SyntaxKind["ObjectType"] = 124] = "ObjectType"; + SyntaxKind[SyntaxKind["FunctionType"] = 125] = "FunctionType"; + SyntaxKind[SyntaxKind["ArrayType"] = 126] = "ArrayType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 127] = "ConstructorType"; + SyntaxKind[SyntaxKind["GenericType"] = 128] = "GenericType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 129] = "TypeQuery"; + SyntaxKind[SyntaxKind["TupleType"] = 130] = "TupleType"; + SyntaxKind[SyntaxKind["UnionType"] = 131] = "UnionType"; + SyntaxKind[SyntaxKind["ParenthesizedType"] = 132] = "ParenthesizedType"; + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 133] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 134] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 135] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 136] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 137] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 138] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 139] = "ExportAssignment"; + SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 140] = "MemberFunctionDeclaration"; + SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 141] = "MemberVariableDeclaration"; + SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 142] = "ConstructorDeclaration"; + SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 143] = "IndexMemberDeclaration"; + SyntaxKind[SyntaxKind["GetAccessor"] = 144] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 145] = "SetAccessor"; + SyntaxKind[SyntaxKind["PropertySignature"] = 146] = "PropertySignature"; + SyntaxKind[SyntaxKind["CallSignature"] = 147] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 148] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 149] = "IndexSignature"; + SyntaxKind[SyntaxKind["MethodSignature"] = 150] = "MethodSignature"; + SyntaxKind[SyntaxKind["Block"] = 151] = "Block"; + SyntaxKind[SyntaxKind["IfStatement"] = 152] = "IfStatement"; + SyntaxKind[SyntaxKind["VariableStatement"] = 153] = "VariableStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 154] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 155] = "ReturnStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 156] = "SwitchStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 157] = "BreakStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 158] = "ContinueStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 159] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 160] = "ForInStatement"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 161] = "EmptyStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 162] = "ThrowStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 163] = "WhileStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 164] = "TryStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 165] = "LabeledStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 166] = "DoStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 167] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 168] = "WithStatement"; + SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 169] = "PrefixUnaryExpression"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 170] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 171] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 172] = "VoidExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 173] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["BinaryExpression"] = 174] = "BinaryExpression"; + SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 175] = "PostfixUnaryExpression"; + SyntaxKind[SyntaxKind["MemberAccessExpression"] = 176] = "MemberAccessExpression"; + SyntaxKind[SyntaxKind["InvocationExpression"] = 177] = "InvocationExpression"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 178] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 179] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 180] = "ObjectCreationExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 181] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 182] = "ParenthesizedArrowFunctionExpression"; + SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 183] = "SimpleArrowFunctionExpression"; + SyntaxKind[SyntaxKind["CastExpression"] = 184] = "CastExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 185] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 186] = "FunctionExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 187] = "OmittedExpression"; + SyntaxKind[SyntaxKind["TemplateExpression"] = 188] = "TemplateExpression"; + SyntaxKind[SyntaxKind["TemplateAccessExpression"] = 189] = "TemplateAccessExpression"; + SyntaxKind[SyntaxKind["VariableDeclaration"] = 190] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarator"] = 191] = "VariableDeclarator"; + SyntaxKind[SyntaxKind["ArgumentList"] = 192] = "ArgumentList"; + SyntaxKind[SyntaxKind["ParameterList"] = 193] = "ParameterList"; + SyntaxKind[SyntaxKind["TypeArgumentList"] = 194] = "TypeArgumentList"; + SyntaxKind[SyntaxKind["TypeParameterList"] = 195] = "TypeParameterList"; + SyntaxKind[SyntaxKind["HeritageClause"] = 196] = "HeritageClause"; + SyntaxKind[SyntaxKind["EqualsValueClause"] = 197] = "EqualsValueClause"; + SyntaxKind[SyntaxKind["CaseSwitchClause"] = 198] = "CaseSwitchClause"; + SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 199] = "DefaultSwitchClause"; + SyntaxKind[SyntaxKind["ElseClause"] = 200] = "ElseClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 201] = "CatchClause"; + SyntaxKind[SyntaxKind["FinallyClause"] = 202] = "FinallyClause"; + SyntaxKind[SyntaxKind["TemplateClause"] = 203] = "TemplateClause"; + SyntaxKind[SyntaxKind["TypeParameter"] = 204] = "TypeParameter"; + SyntaxKind[SyntaxKind["Constraint"] = 205] = "Constraint"; + SyntaxKind[SyntaxKind["SimplePropertyAssignment"] = 206] = "SimplePropertyAssignment"; + SyntaxKind[SyntaxKind["FunctionPropertyAssignment"] = 207] = "FunctionPropertyAssignment"; + SyntaxKind[SyntaxKind["Parameter"] = 208] = "Parameter"; + SyntaxKind[SyntaxKind["EnumElement"] = 209] = "EnumElement"; + SyntaxKind[SyntaxKind["TypeAnnotation"] = 210] = "TypeAnnotation"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 211] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 212] = "ModuleNameModuleReference"; SyntaxKind[SyntaxKind["FirstStandardKeyword"] = SyntaxKind.BreakKeyword] = "FirstStandardKeyword"; SyntaxKind[SyntaxKind["LastStandardKeyword"] = SyntaxKind.WithKeyword] = "LastStandardKeyword"; SyntaxKind[SyntaxKind["FirstFutureReservedKeyword"] = SyntaxKind.ClassKeyword] = "FirstFutureReservedKeyword"; @@ -643,111 +650,111 @@ var TypeScript; var SyntaxFacts; (function (SyntaxFacts) { var textToKeywordKind = { - "any": 58 /* AnyKeyword */, - "boolean": 59 /* BooleanKeyword */, - "break": 13 /* BreakKeyword */, - "case": 14 /* CaseKeyword */, - "catch": 15 /* CatchKeyword */, - "class": 42 /* ClassKeyword */, - "continue": 16 /* ContinueKeyword */, - "const": 43 /* ConstKeyword */, - "constructor": 60 /* ConstructorKeyword */, - "debugger": 17 /* DebuggerKeyword */, - "declare": 61 /* DeclareKeyword */, - "default": 18 /* DefaultKeyword */, - "delete": 19 /* DeleteKeyword */, - "do": 20 /* DoKeyword */, - "else": 21 /* ElseKeyword */, - "enum": 44 /* EnumKeyword */, - "export": 45 /* ExportKeyword */, - "extends": 46 /* ExtendsKeyword */, - "false": 22 /* FalseKeyword */, - "finally": 23 /* FinallyKeyword */, - "for": 24 /* ForKeyword */, - "function": 25 /* FunctionKeyword */, - "get": 62 /* GetKeyword */, - "if": 26 /* IfKeyword */, - "implements": 49 /* ImplementsKeyword */, - "import": 47 /* ImportKeyword */, - "in": 27 /* InKeyword */, - "instanceof": 28 /* InstanceOfKeyword */, - "interface": 50 /* InterfaceKeyword */, - "let": 51 /* LetKeyword */, - "module": 63 /* ModuleKeyword */, - "new": 29 /* NewKeyword */, - "null": 30 /* NullKeyword */, - "number": 65 /* NumberKeyword */, - "package": 52 /* PackageKeyword */, - "private": 53 /* PrivateKeyword */, - "protected": 54 /* ProtectedKeyword */, - "public": 55 /* PublicKeyword */, - "require": 64 /* RequireKeyword */, - "return": 31 /* ReturnKeyword */, - "set": 66 /* SetKeyword */, - "static": 56 /* StaticKeyword */, - "string": 67 /* StringKeyword */, - "super": 48 /* SuperKeyword */, - "switch": 32 /* SwitchKeyword */, - "this": 33 /* ThisKeyword */, - "throw": 34 /* ThrowKeyword */, - "true": 35 /* TrueKeyword */, - "try": 36 /* TryKeyword */, - "typeof": 37 /* TypeOfKeyword */, - "var": 38 /* VarKeyword */, - "void": 39 /* VoidKeyword */, - "while": 40 /* WhileKeyword */, - "with": 41 /* WithKeyword */, - "yield": 57 /* YieldKeyword */, - "{": 68 /* OpenBraceToken */, - "}": 69 /* CloseBraceToken */, - "(": 70 /* OpenParenToken */, - ")": 71 /* CloseParenToken */, - "[": 72 /* OpenBracketToken */, - "]": 73 /* CloseBracketToken */, - ".": 74 /* DotToken */, - "...": 75 /* DotDotDotToken */, - ";": 76 /* SemicolonToken */, - ",": 77 /* CommaToken */, - "<": 78 /* LessThanToken */, - ">": 79 /* GreaterThanToken */, - "<=": 80 /* LessThanEqualsToken */, - ">=": 81 /* GreaterThanEqualsToken */, - "==": 82 /* EqualsEqualsToken */, - "=>": 83 /* EqualsGreaterThanToken */, - "!=": 84 /* ExclamationEqualsToken */, - "===": 85 /* EqualsEqualsEqualsToken */, - "!==": 86 /* ExclamationEqualsEqualsToken */, - "+": 87 /* PlusToken */, - "-": 88 /* MinusToken */, - "*": 89 /* AsteriskToken */, - "%": 90 /* PercentToken */, - "++": 91 /* PlusPlusToken */, - "--": 92 /* MinusMinusToken */, - "<<": 93 /* LessThanLessThanToken */, - ">>": 94 /* GreaterThanGreaterThanToken */, - ">>>": 95 /* GreaterThanGreaterThanGreaterThanToken */, - "&": 96 /* AmpersandToken */, - "|": 97 /* BarToken */, - "^": 98 /* CaretToken */, - "!": 99 /* ExclamationToken */, - "~": 100 /* TildeToken */, - "&&": 101 /* AmpersandAmpersandToken */, - "||": 102 /* BarBarToken */, - "?": 103 /* QuestionToken */, - ":": 104 /* ColonToken */, - "=": 105 /* EqualsToken */, - "+=": 106 /* PlusEqualsToken */, - "-=": 107 /* MinusEqualsToken */, - "*=": 108 /* AsteriskEqualsToken */, - "%=": 109 /* PercentEqualsToken */, - "<<=": 110 /* LessThanLessThanEqualsToken */, - ">>=": 111 /* GreaterThanGreaterThanEqualsToken */, - ">>>=": 112 /* GreaterThanGreaterThanGreaterThanEqualsToken */, - "&=": 113 /* AmpersandEqualsToken */, - "|=": 114 /* BarEqualsToken */, - "^=": 115 /* CaretEqualsToken */, - "/": 116 /* SlashToken */, - "/=": 117 /* SlashEqualsToken */ + "any": 62 /* AnyKeyword */, + "boolean": 63 /* BooleanKeyword */, + "break": 17 /* BreakKeyword */, + "case": 18 /* CaseKeyword */, + "catch": 19 /* CatchKeyword */, + "class": 46 /* ClassKeyword */, + "continue": 20 /* ContinueKeyword */, + "const": 47 /* ConstKeyword */, + "constructor": 64 /* ConstructorKeyword */, + "debugger": 21 /* DebuggerKeyword */, + "declare": 65 /* DeclareKeyword */, + "default": 22 /* DefaultKeyword */, + "delete": 23 /* DeleteKeyword */, + "do": 24 /* DoKeyword */, + "else": 25 /* ElseKeyword */, + "enum": 48 /* EnumKeyword */, + "export": 49 /* ExportKeyword */, + "extends": 50 /* ExtendsKeyword */, + "false": 26 /* FalseKeyword */, + "finally": 27 /* FinallyKeyword */, + "for": 28 /* ForKeyword */, + "function": 29 /* FunctionKeyword */, + "get": 66 /* GetKeyword */, + "if": 30 /* IfKeyword */, + "implements": 53 /* ImplementsKeyword */, + "import": 51 /* ImportKeyword */, + "in": 31 /* InKeyword */, + "instanceof": 32 /* InstanceOfKeyword */, + "interface": 54 /* InterfaceKeyword */, + "let": 55 /* LetKeyword */, + "module": 67 /* ModuleKeyword */, + "new": 33 /* NewKeyword */, + "null": 34 /* NullKeyword */, + "number": 69 /* NumberKeyword */, + "package": 56 /* PackageKeyword */, + "private": 57 /* PrivateKeyword */, + "protected": 58 /* ProtectedKeyword */, + "public": 59 /* PublicKeyword */, + "require": 68 /* RequireKeyword */, + "return": 35 /* ReturnKeyword */, + "set": 70 /* SetKeyword */, + "static": 60 /* StaticKeyword */, + "string": 71 /* StringKeyword */, + "super": 52 /* SuperKeyword */, + "switch": 36 /* SwitchKeyword */, + "this": 37 /* ThisKeyword */, + "throw": 38 /* ThrowKeyword */, + "true": 39 /* TrueKeyword */, + "try": 40 /* TryKeyword */, + "typeof": 41 /* TypeOfKeyword */, + "var": 42 /* VarKeyword */, + "void": 43 /* VoidKeyword */, + "while": 44 /* WhileKeyword */, + "with": 45 /* WithKeyword */, + "yield": 61 /* YieldKeyword */, + "{": 72 /* OpenBraceToken */, + "}": 73 /* CloseBraceToken */, + "(": 74 /* OpenParenToken */, + ")": 75 /* CloseParenToken */, + "[": 76 /* OpenBracketToken */, + "]": 77 /* CloseBracketToken */, + ".": 78 /* DotToken */, + "...": 79 /* DotDotDotToken */, + ";": 80 /* SemicolonToken */, + ",": 81 /* CommaToken */, + "<": 82 /* LessThanToken */, + ">": 83 /* GreaterThanToken */, + "<=": 84 /* LessThanEqualsToken */, + ">=": 85 /* GreaterThanEqualsToken */, + "==": 86 /* EqualsEqualsToken */, + "=>": 87 /* EqualsGreaterThanToken */, + "!=": 88 /* ExclamationEqualsToken */, + "===": 89 /* EqualsEqualsEqualsToken */, + "!==": 90 /* ExclamationEqualsEqualsToken */, + "+": 91 /* PlusToken */, + "-": 92 /* MinusToken */, + "*": 93 /* AsteriskToken */, + "%": 94 /* PercentToken */, + "++": 95 /* PlusPlusToken */, + "--": 96 /* MinusMinusToken */, + "<<": 97 /* LessThanLessThanToken */, + ">>": 98 /* GreaterThanGreaterThanToken */, + ">>>": 99 /* GreaterThanGreaterThanGreaterThanToken */, + "&": 100 /* AmpersandToken */, + "|": 101 /* BarToken */, + "^": 102 /* CaretToken */, + "!": 103 /* ExclamationToken */, + "~": 104 /* TildeToken */, + "&&": 105 /* AmpersandAmpersandToken */, + "||": 106 /* BarBarToken */, + "?": 107 /* QuestionToken */, + ":": 108 /* ColonToken */, + "=": 109 /* EqualsToken */, + "+=": 110 /* PlusEqualsToken */, + "-=": 111 /* MinusEqualsToken */, + "*=": 112 /* AsteriskEqualsToken */, + "%=": 113 /* PercentEqualsToken */, + "<<=": 114 /* LessThanLessThanEqualsToken */, + ">>=": 115 /* GreaterThanGreaterThanEqualsToken */, + ">>>=": 116 /* GreaterThanGreaterThanGreaterThanEqualsToken */, + "&=": 117 /* AmpersandEqualsToken */, + "|=": 118 /* BarEqualsToken */, + "^=": 119 /* CaretEqualsToken */, + "/": 120 /* SlashToken */, + "/=": 121 /* SlashEqualsToken */ }; var kindToText = new Array(); for (var name in textToKeywordKind) { @@ -755,7 +762,7 @@ var TypeScript; kindToText[textToKeywordKind[name]] = name; } } - kindToText[60 /* ConstructorKeyword */] = "constructor"; + kindToText[64 /* ConstructorKeyword */] = "constructor"; function getTokenKind(text) { if (textToKeywordKind.hasOwnProperty(text)) { return textToKeywordKind[text]; @@ -778,12 +785,12 @@ var TypeScript; SyntaxFacts.isAnyPunctuation = isAnyPunctuation; function isPrefixUnaryExpressionOperatorToken(tokenKind) { switch (tokenKind) { - case 87 /* PlusToken */: - case 88 /* MinusToken */: - case 100 /* TildeToken */: - case 99 /* ExclamationToken */: - case 91 /* PlusPlusToken */: - case 92 /* MinusMinusToken */: + case 91 /* PlusToken */: + case 92 /* MinusToken */: + case 104 /* TildeToken */: + case 103 /* ExclamationToken */: + case 95 /* PlusPlusToken */: + case 96 /* MinusMinusToken */: return true; default: return false; @@ -792,42 +799,42 @@ var TypeScript; SyntaxFacts.isPrefixUnaryExpressionOperatorToken = isPrefixUnaryExpressionOperatorToken; function isBinaryExpressionOperatorToken(tokenKind) { switch (tokenKind) { - case 89 /* AsteriskToken */: - case 116 /* SlashToken */: - case 90 /* PercentToken */: - case 87 /* PlusToken */: - case 88 /* MinusToken */: - case 93 /* LessThanLessThanToken */: - case 94 /* GreaterThanGreaterThanToken */: - case 95 /* GreaterThanGreaterThanGreaterThanToken */: - case 78 /* LessThanToken */: - case 79 /* GreaterThanToken */: - case 80 /* LessThanEqualsToken */: - case 81 /* GreaterThanEqualsToken */: - case 28 /* InstanceOfKeyword */: - case 27 /* InKeyword */: - case 82 /* EqualsEqualsToken */: - case 84 /* ExclamationEqualsToken */: - case 85 /* EqualsEqualsEqualsToken */: - case 86 /* ExclamationEqualsEqualsToken */: - case 96 /* AmpersandToken */: - case 98 /* CaretToken */: - case 97 /* BarToken */: - case 101 /* AmpersandAmpersandToken */: - case 102 /* BarBarToken */: - case 114 /* BarEqualsToken */: - case 113 /* AmpersandEqualsToken */: - case 115 /* CaretEqualsToken */: - case 110 /* LessThanLessThanEqualsToken */: - case 111 /* GreaterThanGreaterThanEqualsToken */: - case 112 /* GreaterThanGreaterThanGreaterThanEqualsToken */: - case 106 /* PlusEqualsToken */: - case 107 /* MinusEqualsToken */: - case 108 /* AsteriskEqualsToken */: - case 117 /* SlashEqualsToken */: - case 109 /* PercentEqualsToken */: - case 105 /* EqualsToken */: - case 77 /* CommaToken */: + case 93 /* AsteriskToken */: + case 120 /* SlashToken */: + case 94 /* PercentToken */: + case 91 /* PlusToken */: + case 92 /* MinusToken */: + case 97 /* LessThanLessThanToken */: + case 98 /* GreaterThanGreaterThanToken */: + case 99 /* GreaterThanGreaterThanGreaterThanToken */: + case 82 /* LessThanToken */: + case 83 /* GreaterThanToken */: + case 84 /* LessThanEqualsToken */: + case 85 /* GreaterThanEqualsToken */: + case 32 /* InstanceOfKeyword */: + case 31 /* InKeyword */: + case 86 /* EqualsEqualsToken */: + case 88 /* ExclamationEqualsToken */: + case 89 /* EqualsEqualsEqualsToken */: + case 90 /* ExclamationEqualsEqualsToken */: + case 100 /* AmpersandToken */: + case 102 /* CaretToken */: + case 101 /* BarToken */: + case 105 /* AmpersandAmpersandToken */: + case 106 /* BarBarToken */: + case 118 /* BarEqualsToken */: + case 117 /* AmpersandEqualsToken */: + case 119 /* CaretEqualsToken */: + case 114 /* LessThanLessThanEqualsToken */: + case 115 /* GreaterThanGreaterThanEqualsToken */: + case 116 /* GreaterThanGreaterThanGreaterThanEqualsToken */: + case 110 /* PlusEqualsToken */: + case 111 /* MinusEqualsToken */: + case 112 /* AsteriskEqualsToken */: + case 121 /* SlashEqualsToken */: + case 113 /* PercentEqualsToken */: + case 109 /* EqualsToken */: + case 81 /* CommaToken */: return true; default: return false; @@ -836,18 +843,18 @@ var TypeScript; SyntaxFacts.isBinaryExpressionOperatorToken = isBinaryExpressionOperatorToken; function isAssignmentOperatorToken(tokenKind) { switch (tokenKind) { - case 114 /* BarEqualsToken */: - case 113 /* AmpersandEqualsToken */: - case 115 /* CaretEqualsToken */: - case 110 /* LessThanLessThanEqualsToken */: - case 111 /* GreaterThanGreaterThanEqualsToken */: - case 112 /* GreaterThanGreaterThanGreaterThanEqualsToken */: - case 106 /* PlusEqualsToken */: - case 107 /* MinusEqualsToken */: - case 108 /* AsteriskEqualsToken */: - case 117 /* SlashEqualsToken */: - case 109 /* PercentEqualsToken */: - case 105 /* EqualsToken */: + case 118 /* BarEqualsToken */: + case 117 /* AmpersandEqualsToken */: + case 119 /* CaretEqualsToken */: + case 114 /* LessThanLessThanEqualsToken */: + case 115 /* GreaterThanGreaterThanEqualsToken */: + case 116 /* GreaterThanGreaterThanGreaterThanEqualsToken */: + case 110 /* PlusEqualsToken */: + case 111 /* MinusEqualsToken */: + case 112 /* AsteriskEqualsToken */: + case 121 /* SlashEqualsToken */: + case 113 /* PercentEqualsToken */: + case 109 /* EqualsToken */: return true; default: return false; @@ -856,18 +863,18 @@ var TypeScript; SyntaxFacts.isAssignmentOperatorToken = isAssignmentOperatorToken; function isType(kind) { switch (kind) { - case 122 /* ArrayType */: - case 58 /* AnyKeyword */: - case 65 /* NumberKeyword */: - case 59 /* BooleanKeyword */: - case 67 /* StringKeyword */: - case 39 /* VoidKeyword */: - case 121 /* FunctionType */: - case 120 /* ObjectType */: - case 123 /* ConstructorType */: - case 125 /* TypeQuery */: - case 124 /* GenericType */: - case 119 /* QualifiedName */: + case 126 /* ArrayType */: + case 62 /* AnyKeyword */: + case 69 /* NumberKeyword */: + case 63 /* BooleanKeyword */: + case 71 /* StringKeyword */: + case 43 /* VoidKeyword */: + case 125 /* FunctionType */: + case 124 /* ObjectType */: + case 127 /* ConstructorType */: + case 129 /* TypeQuery */: + case 128 /* GenericType */: + case 123 /* QualifiedName */: case 9 /* IdentifierName */: return true; } @@ -1288,6 +1295,32 @@ var definitions = [ { name: 'closeBracketToken', isToken: true, excludeFromAST: true } ] }, + { + name: 'TemplateAccessExpressionSyntax', + baseType: 'ISyntaxNode', + interfaces: ['IMemberExpressionSyntax', 'ICallExpressionSyntax'], + children: [ + { name: 'expression', type: 'ILeftHandSideExpressionSyntax' }, + { name: 'templateExpression', type: 'IPrimaryExpressionSyntax' }, + ] + }, + { + name: 'TemplateExpressionSyntax', + baseType: 'ISyntaxNode', + interfaces: ['IPrimaryExpressionSyntax'], + children: [ + { name: 'templateStartToken', isToken: true, excludeFromAST: true }, + { name: 'templateClauses', isList: true, elementType: 'TemplateClauseSyntax' }, + ] + }, + { + name: 'TemplateClauseSyntax', + baseType: 'ISyntaxNode', + children: [ + { name: 'expression', type: 'IExpressionSyntax' }, + { name: 'templateMiddleOrEndToken', isToken: true, elementType: 'TemplateSpanSyntax' }, + ] + }, { name: 'InvocationExpressionSyntax', baseType: 'ISyntaxNode', @@ -1839,7 +1872,7 @@ var definitions = [ } ]; function firstKind(definition) { - var kindName = definition.syntaxKinds ? definition.syntaxKinds[0] : getNameWithoutSuffix(definition); + var kindName = getNameWithoutSuffix(definition); var kind = TypeScript.SyntaxKind[kindName]; return kind; } @@ -2580,9 +2613,6 @@ function getDefinitionForKind(kind) { if (getNameWithoutSuffix(d) === kindName) { return true; } - if (d.syntaxKinds) { - return TypeScript.ArrayUtilities.contains(d.syntaxKinds, kindName); - } return false; }); } @@ -2971,14 +3001,7 @@ function generateIsTypeScriptSpecific() { if (!definition.isTypeScriptSpecific) { continue; } - if (definition.syntaxKinds) { - for (var j = 0; j < definition.syntaxKinds.length; j++) { - result += " case SyntaxKind." + definition.syntaxKinds[j] + ":\r\n"; - } - } - else { - result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; - } + result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; } result += " return true;\r\n"; var triviallyFalseDefinitions = definitions.filter(function (d) { return d.children.filter(function (c) { return c.type !== "SyntaxKind" && !c.isToken; }).length === 0; }); @@ -2987,14 +3010,7 @@ function generateIsTypeScriptSpecific() { if (definition.isTypeScriptSpecific) { continue; } - if (definition.syntaxKinds) { - for (var j = 0; j < definition.syntaxKinds.length; j++) { - result += " case SyntaxKind." + definition.syntaxKinds[j] + ":\r\n"; - } - } - else { - result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; - } + result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; } result += " return false;\r\n"; for (var i = 0; i < definitions.length; i++) { @@ -3005,15 +3021,7 @@ function generateIsTypeScriptSpecific() { if (definition.children.filter(function (c) { return c.type !== "SyntaxKind" && !c.isToken; }).length === 0) { continue; } - if (definition.syntaxKinds) { - result += " "; - for (var j = 0; j < definition.syntaxKinds.length; j++) { - result += " case SyntaxKind." + definition.syntaxKinds[j] + ":"; - } - } - else { - result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":"; - } + result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":"; result += "\r\n"; result += " return is" + getNameWithoutSuffix(definition) + "TypeScriptSpecific(<" + definition.name + ">element);\r\n"; } @@ -3076,7 +3084,6 @@ var visitor = generateVisitor(); var defaultVisitor = generateDefaultVisitor(); var servicesUtilities = generateServicesUtilities(); 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); diff --git a/src/services/syntax/defaultSyntaxVisitor.generated.ts b/src/services/syntax/defaultSyntaxVisitor.generated.ts index ceaa8a4fcf382..0ce967ac613b4 100644 --- a/src/services/syntax/defaultSyntaxVisitor.generated.ts +++ b/src/services/syntax/defaultSyntaxVisitor.generated.ts @@ -274,6 +274,14 @@ module TypeScript { return this.defaultVisit(node); } + public visitTemplateExpression(node: TemplateExpressionSyntax): any { + return this.defaultVisit(node); + } + + public visitTemplateAccessExpression(node: TemplateAccessExpressionSyntax): any { + return this.defaultVisit(node); + } + public visitVariableDeclaration(node: VariableDeclarationSyntax): any { return this.defaultVisit(node); } @@ -326,6 +334,10 @@ module TypeScript { return this.defaultVisit(node); } + public visitTemplateClause(node: TemplateClauseSyntax): any { + return this.defaultVisit(node); + } + public visitTypeParameter(node: TypeParameterSyntax): any { return this.defaultVisit(node); } diff --git a/src/services/syntax/parser.ts b/src/services/syntax/parser.ts index 8572adce30543..d0e556f8d6ce0 100644 --- a/src/services/syntax/parser.ts +++ b/src/services/syntax/parser.ts @@ -465,7 +465,7 @@ module TypeScript.Parser { return Syntax.emptyToken(expectedKind); } - function getExpectedTokenDiagnostic(expectedKind: SyntaxKind, actual: ISyntaxToken, diagnosticCode: string): Diagnostic { + function getExpectedTokenDiagnostic(expectedKind: SyntaxKind, actual?: ISyntaxToken, diagnosticCode?: string): Diagnostic { var token = currentToken(); var args: any[] = undefined; @@ -2133,6 +2133,10 @@ module TypeScript.Parser { case SyntaxKind.StringLiteral: case SyntaxKind.RegularExpressionLiteral: + // Templates + case SyntaxKind.NoSubstitutionTemplateToken: + case SyntaxKind.TemplateStartToken: + // For array literals. case SyntaxKind.OpenBracketToken: @@ -2638,6 +2642,11 @@ module TypeScript.Parser { case SyntaxKind.DotToken: expression = new MemberAccessExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken), eatIdentifierNameToken()); continue; + + case SyntaxKind.NoSubstitutionTemplateToken: + case SyntaxKind.TemplateStartToken: + expression = new TemplateAccessExpressionSyntax(parseNodeData, expression, parseTemplateExpression(_currentToken)); + continue; } return expression; @@ -2657,6 +2666,11 @@ module TypeScript.Parser { case SyntaxKind.DotToken: expression = new MemberAccessExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken), eatIdentifierNameToken()); continue; + + case SyntaxKind.NoSubstitutionTemplateToken: + case SyntaxKind.TemplateStartToken: + expression = new TemplateAccessExpressionSyntax(parseNodeData, expression, parseTemplateExpression(_currentToken)); + continue; } return expression; @@ -2870,11 +2884,15 @@ module TypeScript.Parser { case SyntaxKind.StringLiteral: return consumeToken(_currentToken); - case SyntaxKind.FunctionKeyword: return parseFunctionExpression(_currentToken); - case SyntaxKind.OpenBracketToken: return parseArrayLiteralExpression(_currentToken); - case SyntaxKind.OpenBraceToken: return parseObjectLiteralExpression(_currentToken); - case SyntaxKind.OpenParenToken: return parseParenthesizedExpression(_currentToken); - case SyntaxKind.NewKeyword: return parseObjectCreationExpression(_currentToken); + case SyntaxKind.FunctionKeyword: return parseFunctionExpression(_currentToken); + case SyntaxKind.OpenBracketToken: return parseArrayLiteralExpression(_currentToken); + case SyntaxKind.OpenBraceToken: return parseObjectLiteralExpression(_currentToken); + case SyntaxKind.OpenParenToken: return parseParenthesizedExpression(_currentToken); + case SyntaxKind.NewKeyword: return parseObjectCreationExpression(_currentToken); + + case SyntaxKind.NoSubstitutionTemplateToken: + case SyntaxKind.TemplateStartToken: + return parseTemplateExpression(_currentToken); case SyntaxKind.SlashToken: case SyntaxKind.SlashEqualsToken: @@ -2961,6 +2979,46 @@ module TypeScript.Parser { consumeToken(newKeyword), tryParseMemberExpressionOrHigher(currentToken(), /*force:*/ true, /*inObjectCreation:*/ true), tryParseArgumentList()); } + function parseTemplateExpression(startToken: ISyntaxToken): IPrimaryExpressionSyntax { + consumeToken(startToken); + + if (startToken.kind() === SyntaxKind.NoSubstitutionTemplateToken) { + return startToken; + } + + var templateClausesArray: TemplateClauseSyntax[] = getArray(); + + do { + // Keep consuming template spans as long as the last one we keep getting template + // middle pieces. + templateClausesArray.push(parseTemplateClause()); + } + while (templateClausesArray[templateClausesArray.length - 1].templateMiddleOrEndToken.kind() === SyntaxKind.TemplateMiddleToken); + + var templateClauses = Syntax.list(templateClausesArray); + returnZeroLengthArray(templateClausesArray); + + return new TemplateExpressionSyntax(parseNodeData, startToken, templateClauses); + } + + function parseTemplateClause(): TemplateClauseSyntax { + var expression = parseExpression(/*allowIn:*/ true); + var token = currentToken(); + + if (token.kind() === SyntaxKind.CloseBraceToken) { + token = currentContextualToken(); + Debug.assert(token.kind() === SyntaxKind.TemplateMiddleToken || token.kind() === SyntaxKind.TemplateEndToken); + consumeToken(token); + } + else { + var diagnostic = getExpectedTokenDiagnostic(SyntaxKind.CloseBraceToken); + addDiagnostic(diagnostic); + token = Syntax.emptyToken(SyntaxKind.TemplateEndToken); + } + + return new TemplateClauseSyntax(parseNodeData, expression, token); + } + function parseCastExpression(lessThanToken: ISyntaxToken): CastExpressionSyntax { return new CastExpressionSyntax(parseNodeData, consumeToken(lessThanToken), parseType(), eatToken(SyntaxKind.GreaterThanToken), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true)); @@ -3332,8 +3390,10 @@ module TypeScript.Parser { } } + // We allow a template literal while parser for error tolerance. We'll report errors + // on this later in the grammar checker walker. var kind = token.kind(); - return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral; + return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.NoSubstitutionTemplateToken; } function parseArrayLiteralExpression(openBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax { diff --git a/src/services/syntax/prettyPrinter.ts b/src/services/syntax/prettyPrinter.ts index 2c0441b28f5dd..6f381d75cc99a 100644 --- a/src/services/syntax/prettyPrinter.ts +++ b/src/services/syntax/prettyPrinter.ts @@ -1023,5 +1023,23 @@ module TypeScript.PrettyPrinter { this.appendToken(node.debuggerKeyword); this.appendToken(node.semicolonToken); } + + public visitTemplateExpression(node: TemplateExpressionSyntax): void { + this.appendToken(node.templateStartToken); + this.ensureSpace(); + this.appendSpaceList(node.templateClauses); + } + + public visitTemplateClause(node: TemplateClauseSyntax): void { + node.expression.accept(this); + this.ensureSpace(); + this.appendToken(node.templateMiddleOrEndToken); + } + + public visitTemplateAccessExpression(node: TemplateAccessExpressionSyntax): void { + node.expression.accept(this); + this.ensureSpace(); + node.templateExpression.accept(this); + } } } \ No newline at end of file diff --git a/src/services/syntax/scanner.ts b/src/services/syntax/scanner.ts index 26ede31047da8..a1be20adddb5f 100644 --- a/src/services/syntax/scanner.ts +++ b/src/services/syntax/scanner.ts @@ -178,6 +178,11 @@ module TypeScript.Scanner { case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return true; + // Created by the parser when it sees } while parsing a template expression. + case SyntaxKind.TemplateMiddleToken: + case SyntaxKind.TemplateEndToken: + return true; + default: return token.isKeywordConvertedToIdentifier(); } @@ -708,7 +713,7 @@ module TypeScript.Scanner { while (true) { if (index === end) { - reportDiagnostic(end, 0, DiagnosticCode.AsteriskSlash_expected, undefined); + reportDiagnostic(end, 0, DiagnosticCode._0_expected, ["*/"]); return; } @@ -750,10 +755,10 @@ module TypeScript.Scanner { index++; switch (character) { - case CharacterCodes.exclamation /*33*/: return scanExclamationToken(); + case CharacterCodes.exclamation/*33*/: return scanExclamationToken(); case CharacterCodes.doubleQuote/*34*/: return scanStringLiteral(character); - case CharacterCodes.percent /*37*/: return scanPercentToken(); - case CharacterCodes.ampersand /*38*/: return scanAmpersandToken(); + case CharacterCodes.percent/*37*/: return scanPercentToken(); + case CharacterCodes.ampersand/*38*/: return scanAmpersandToken(); case CharacterCodes.singleQuote/*39*/: return scanStringLiteral(character); case CharacterCodes.openParen/*40*/: return SyntaxKind.OpenParenToken; case CharacterCodes.closeParen/*41*/: return SyntaxKind.CloseParenToken; @@ -779,10 +784,11 @@ module TypeScript.Scanner { case CharacterCodes.openBracket/*91*/: return SyntaxKind.OpenBracketToken; case CharacterCodes.closeBracket/*93*/: return SyntaxKind.CloseBracketToken; case CharacterCodes.caret/*94*/: return scanCaretToken(); + case CharacterCodes.backtick/*96*/: return scanTemplateToken(character); case CharacterCodes.openBrace/*123*/: return SyntaxKind.OpenBraceToken; case CharacterCodes.bar/*124*/: return scanBarToken(); - case CharacterCodes.closeBrace/*125*/: return SyntaxKind.CloseBraceToken; + case CharacterCodes.closeBrace/*125*/: return scanCloseBraceToken(allowContextualToken, character); case CharacterCodes.tilde/*126*/: return SyntaxKind.TildeToken; } @@ -1081,6 +1087,39 @@ module TypeScript.Scanner { } } + function scanCloseBraceToken(allowContextualToken: boolean, startChar: number): SyntaxKind { + return allowContextualToken ? scanTemplateToken(startChar) : SyntaxKind.CloseBraceToken; + } + + function scanTemplateToken(startChar: number): SyntaxKind { + var startedWithBacktick = startChar === CharacterCodes.backtick; + + while (true) { + if (index === end) { + // Hit the end of the file. + reportDiagnostic(end, 0, DiagnosticCode._0_expected, ["`"]); + break; + } + + var ch = str.charCodeAt(index); + index++; + + if (ch === CharacterCodes.backtick) { + break; + } + + if (ch === CharacterCodes.$ && + index < end && + str.charCodeAt(index) === CharacterCodes.openBrace) { + + index++; + return startedWithBacktick ? SyntaxKind.TemplateStartToken : SyntaxKind.TemplateMiddleToken; + } + } + + return startedWithBacktick ? SyntaxKind.NoSubstitutionTemplateToken : SyntaxKind.TemplateEndToken; + } + function scanAmpersandToken(): SyntaxKind { var character = str.charCodeAt(index); if (character === CharacterCodes.equals) { diff --git a/src/services/syntax/syntaxGenerator.ts b/src/services/syntax/syntaxGenerator.ts index abd964d108c1f..7ab1dfc289ab3 100644 --- a/src/services/syntax/syntaxGenerator.ts +++ b/src/services/syntax/syntaxGenerator.ts @@ -15,7 +15,6 @@ interface ITypeDefinition { baseType: string; interfaces?: string[]; children: IMemberDefinition[]; - syntaxKinds?: string[]; isTypeScriptSpecific: boolean; } @@ -192,7 +191,7 @@ var definitions:ITypeDefinition[] = [ name: 'VariableDeclaratorSyntax', baseType: 'ISyntaxNode', children: [ - { name: 'propertyName', isToken: true, tokenKinds: ['IdentifierName', 'StringLiteral', 'NumericLiteral'] }, + { name: 'propertyName', isToken: true }, { name: 'typeAnnotation', type: 'TypeAnnotationSyntax', isOptional: true, isTypeScriptSpecific: true }, { name: 'equalsValueClause', type: 'EqualsValueClauseSyntax', isOptional: true } ] @@ -448,6 +447,32 @@ var definitions:ITypeDefinition[] = [ { name: 'closeBracketToken', isToken: true, excludeFromAST: true } ] }, + { + name: 'TemplateAccessExpressionSyntax', + baseType: 'ISyntaxNode', + interfaces: ['IMemberExpressionSyntax', 'ICallExpressionSyntax'], + children: [ + { name: 'expression', type: 'ILeftHandSideExpressionSyntax' }, + { name: 'templateExpression', type: 'IPrimaryExpressionSyntax' }, + ] + }, + { + name: 'TemplateExpressionSyntax', + baseType: 'ISyntaxNode', + interfaces: ['IPrimaryExpressionSyntax'], + children: [ + { name: 'templateStartToken', isToken: true, excludeFromAST: true }, + { name: 'templateClauses', isList: true, elementType: 'TemplateClauseSyntax' }, + ] + }, + { + name: 'TemplateClauseSyntax', + baseType: 'ISyntaxNode', + children: [ + { name: 'expression', type: 'IExpressionSyntax' }, + { name: 'templateMiddleOrEndToken', isToken: true, elementType: 'TemplateSpanSyntax' }, + ] + }, { name: 'InvocationExpressionSyntax', baseType: 'ISyntaxNode', @@ -989,7 +1014,7 @@ var definitions:ITypeDefinition[] = [ }]; function firstKind(definition: ITypeDefinition): TypeScript.SyntaxKind { - var kindName = definition.syntaxKinds ? definition.syntaxKinds[0] : getNameWithoutSuffix(definition); + var kindName = getNameWithoutSuffix(definition); //TypeScript.Environment.standardOut.WriteLine(kindName); var kind = (TypeScript.SyntaxKind)[kindName]; //TypeScript.Environment.standardOut.WriteLine(kind); @@ -2013,10 +2038,6 @@ function getDefinitionForKind(kind: TypeScript.SyntaxKind): ITypeDefinition { return true; } - if (d.syntaxKinds) { - return TypeScript.ArrayUtilities.contains(d.syntaxKinds, kindName); - } - return false; }); } @@ -2637,14 +2658,7 @@ function generateIsTypeScriptSpecific(): string { continue; } - if (definition.syntaxKinds) { - for (var j = 0; j < definition.syntaxKinds.length; j++) { - result += " case SyntaxKind." + definition.syntaxKinds[j] + ":\r\n"; - } - } - else { - result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; - } + result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; } result += " return true;\r\n"; @@ -2656,14 +2670,7 @@ function generateIsTypeScriptSpecific(): string { continue; } - if (definition.syntaxKinds) { - for (var j = 0; j < definition.syntaxKinds.length; j++) { - result += " case SyntaxKind." + definition.syntaxKinds[j] + ":\r\n"; - } - } - else { - result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; - } + result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n"; } result += " return false;\r\n"; @@ -2678,15 +2685,7 @@ function generateIsTypeScriptSpecific(): string { continue; } - if (definition.syntaxKinds) { - result += " "; - for (var j = 0; j < definition.syntaxKinds.length; j++) { - result += " case SyntaxKind." + definition.syntaxKinds[j] + ":"; - } - } - else { - result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":"; - } + result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ":"; result += "\r\n"; result += " return is" + getNameWithoutSuffix(definition) + "TypeScriptSpecific(<" + definition.name + ">element);\r\n"; } diff --git a/src/services/syntax/syntaxKind.ts b/src/services/syntax/syntaxKind.ts index a009a458dd5eb..8af2e944834cb 100644 --- a/src/services/syntax/syntaxKind.ts +++ b/src/services/syntax/syntaxKind.ts @@ -26,6 +26,12 @@ module TypeScript { NumericLiteral, StringLiteral, + // Template tokens + NoSubstitutionTemplateToken, + TemplateStartToken, + TemplateMiddleToken, + TemplateEndToken, + // All fixed width tokens follow. // Keywords @@ -226,6 +232,8 @@ module TypeScript { ElementAccessExpression, FunctionExpression, OmittedExpression, + TemplateExpression, + TemplateAccessExpression, // Variable declarations VariableDeclaration, @@ -245,6 +253,7 @@ module TypeScript { ElseClause, CatchClause, FinallyClause, + TemplateClause, // Generics TypeParameter, diff --git a/src/services/syntax/syntaxNodes.concrete.generated.ts b/src/services/syntax/syntaxNodes.concrete.generated.ts index 01975e12ae3f4..7b3674b29a478 100644 --- a/src/services/syntax/syntaxNodes.concrete.generated.ts +++ b/src/services/syntax/syntaxNodes.concrete.generated.ts @@ -2584,6 +2584,70 @@ module TypeScript { return visitor.visitOmittedExpression(this); } } + export class TemplateExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax { + public templateStartToken: ISyntaxToken; + public templateClauses: TemplateClauseSyntax[]; + public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; + constructor(data: number, templateStartToken: ISyntaxToken, templateClauses: TemplateClauseSyntax[]) { + super(data); + this.templateStartToken = templateStartToken, + this.templateClauses = templateClauses, + templateStartToken.parent = this, + !isShared(templateClauses) && (templateClauses.parent = this); + } + + public kind(): SyntaxKind { + return SyntaxKind.TemplateExpression; + } + + public childCount(): number { + return 2; + } + + public childAt(slot: number): ISyntaxElement { + switch (slot) { + case 0: return this.templateStartToken; + case 1: return this.templateClauses; + default: throw Errors.invalidOperation(); + } + } + + public accept(visitor: ISyntaxVisitor): SyntaxKind { + return visitor.visitTemplateExpression(this); + } + } + export class TemplateAccessExpressionSyntax extends SyntaxNode implements IMemberExpressionSyntax, ICallExpressionSyntax { + public expression: ILeftHandSideExpressionSyntax; + public templateExpression: IPrimaryExpressionSyntax; + public _memberExpressionBrand: any; public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; + constructor(data: number, expression: ILeftHandSideExpressionSyntax, templateExpression: IPrimaryExpressionSyntax) { + super(data); + this.expression = expression, + this.templateExpression = templateExpression, + expression.parent = this, + templateExpression.parent = this; + } + + public kind(): SyntaxKind { + return SyntaxKind.TemplateAccessExpression; + } + + public childCount(): number { + return 2; + } + + public childAt(slot: number): ISyntaxElement { + switch (slot) { + case 0: return this.expression; + case 1: return this.templateExpression; + default: throw Errors.invalidOperation(); + } + } + + public accept(visitor: ISyntaxVisitor): SyntaxKind { + return visitor.visitTemplateAccessExpression(this); + } + } export class VariableDeclarationSyntax extends SyntaxNode { public varKeyword: ISyntaxToken; public variableDeclarators: ISeparatedSyntaxList; @@ -3041,6 +3105,37 @@ module TypeScript { return visitor.visitFinallyClause(this); } } + export class TemplateClauseSyntax extends SyntaxNode { + public expression: IExpressionSyntax; + public templateMiddleOrEndToken: ISyntaxToken; + constructor(data: number, expression: IExpressionSyntax, templateMiddleOrEndToken: ISyntaxToken) { + super(data); + this.expression = expression, + this.templateMiddleOrEndToken = templateMiddleOrEndToken, + expression.parent = this, + templateMiddleOrEndToken.parent = this; + } + + public kind(): SyntaxKind { + return SyntaxKind.TemplateClause; + } + + public childCount(): number { + return 2; + } + + public childAt(slot: number): ISyntaxElement { + switch (slot) { + case 0: return this.expression; + case 1: return this.templateMiddleOrEndToken; + default: throw Errors.invalidOperation(); + } + } + + public accept(visitor: ISyntaxVisitor): SyntaxKind { + return visitor.visitTemplateClause(this); + } + } export class TypeParameterSyntax extends SyntaxNode { public identifier: ISyntaxToken; public constraint: ConstraintSyntax; diff --git a/src/services/syntax/syntaxToken.ts b/src/services/syntax/syntaxToken.ts index 0ded9c44891b6..990618e4c1efd 100644 --- a/src/services/syntax/syntaxToken.ts +++ b/src/services/syntax/syntaxToken.ts @@ -98,15 +98,23 @@ module TypeScript { return IntegerUtilities.isHexInteger(text) ? parseInt(text, /*radix:*/ 16) : parseFloat(text); } else if (kind === SyntaxKind.StringLiteral) { - if (text.length > 1 && text.charCodeAt(text.length - 1) === text.charCodeAt(0)) { - // Properly terminated. Remove the quotes, and massage any escape characters we see. - return massageEscapes(text.substr(1, text.length - 2)); - } - else { - // Not property terminated. Remove the first quote and massage any escape characters we see. - return massageEscapes(text.substr(1)); - - } + return (text.length > 1 && text.charCodeAt(text.length - 1) === text.charCodeAt(0)) + ? massageEscapes(text.substr(1, text.length - "''".length)) + : massageEscapes(text.substr(1)); + } + else if (kind === SyntaxKind.NoSubstitutionTemplateToken || kind === SyntaxKind.TemplateEndToken) { + // Both of these template types may be missing their closing backtick (if they were at + // the end of the file). Check to make sure it is there before grabbing the portion + // we're examining. + return (text.length > 1 && text.charCodeAt(text.length - 1) === CharacterCodes.backtick) + ? massageTemplate(text.substr(1, text.length - "``".length)) + : massageTemplate(text.substr(1)); + } + else if (kind === SyntaxKind.TemplateStartToken || kind === SyntaxKind.TemplateMiddleToken) { + // Both these tokens must have been properly ended. i.e. if it didn't end with a ${ + // then we would not have parsed a start or middle token out at all. So we don't + // need to check for an incomplete token. + return massageTemplate(text.substr(1, text.length - "`${".length)); } else if (kind === SyntaxKind.RegularExpressionLiteral) { return regularExpressionValue(text); @@ -124,6 +132,18 @@ module TypeScript { return value === undefined ? "" : massageDisallowedIdentifiers(value.toString()); } + function massageTemplate(text: string): string { + // First, convert all carriage-return newlines into line-feed newlines. This is due to: + // + // The TRV of LineTerminatorSequence :: is the code unit value 0x000A. + // ... + // The TRV of LineTerminatorSequence :: is the sequence consisting of the code unit value 0x000A. + text = text.replace("\r\n", "\n").replace("\r", "\n"); + + // Now remove any escape characters that may be in the string. + return massageEscapes(text); + } + export function massageEscapes(text: string): string { return text.indexOf("\\") >= 0 ? convertEscapes(text) : text; } diff --git a/src/services/syntax/syntaxTree.ts b/src/services/syntax/syntaxTree.ts index 6f0b547b4a164..3e107bc527bc2 100644 --- a/src/services/syntax/syntaxTree.ts +++ b/src/services/syntax/syntaxTree.ts @@ -555,8 +555,25 @@ module TypeScript { super.visitMemberVariableDeclaration(node); } + public visitMethodSignature(node: MethodSignatureSyntax): void { + if (this.checkForTemplatePropertyName(node.propertyName)) { + return; + } + + super.visitMethodSignature(node); + } + + public visitPropertySignature(node: PropertySignatureSyntax): void { + if (this.checkForTemplatePropertyName(node.propertyName)) { + return; + } + + super.visitPropertySignature(node); + } + public visitMemberFunctionDeclaration(node: MemberFunctionDeclarationSyntax): void { - if (this.checkClassElementModifiers(node.modifiers)) { + if (this.checkClassElementModifiers(node.modifiers) || + this.checkForTemplatePropertyName(node.propertyName)) { return; } @@ -589,7 +606,7 @@ module TypeScript { return false; } - private checkEcmaScriptVersionIsAtLeast(parent: ISyntaxElement, reportToken: ISyntaxToken, languageVersion: ts.ScriptTarget, diagnosticKey: string): boolean { + private checkEcmaScriptVersionIsAtLeast(reportToken: ISyntaxToken, languageVersion: ts.ScriptTarget, diagnosticKey: string): boolean { if (this.syntaxTree.languageVersion() < languageVersion) { this.pushDiagnostic(reportToken, diagnosticKey); return true; @@ -607,11 +624,12 @@ module TypeScript { public visitGetAccessor(node: GetAccessorSyntax): void { if (this.checkForAccessorDeclarationInAmbientContext(node) || - this.checkEcmaScriptVersionIsAtLeast(node, node.propertyName, ts.ScriptTarget.ES5, DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || + this.checkEcmaScriptVersionIsAtLeast(node.propertyName, ts.ScriptTarget.ES5, DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkForDisallowedAccessorTypeParameters(node.callSignature) || - this.checkGetAccessorParameter(node)) { + this.checkGetAccessorParameter(node) || + this.checkForTemplatePropertyName(node.propertyName)) { return; } @@ -672,14 +690,23 @@ module TypeScript { return false; } + public visitSimplePropertyAssignment(node: SimplePropertyAssignmentSyntax): void { + if (this.checkForTemplatePropertyName(node.propertyName)) { + return; + } + + super.visitSimplePropertyAssignment(node); + } + public visitSetAccessor(node: SetAccessorSyntax): void { if (this.checkForAccessorDeclarationInAmbientContext(node) || - this.checkEcmaScriptVersionIsAtLeast(node, node.propertyName, ts.ScriptTarget.ES5, DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || + this.checkEcmaScriptVersionIsAtLeast(node.propertyName, ts.ScriptTarget.ES5, DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkForDisallowedAccessorTypeParameters(node.callSignature) || this.checkForDisallowedSetAccessorTypeAnnotation(node) || - this.checkSetAccessorParameter(node)) { + this.checkSetAccessorParameter(node) || + this.checkForTemplatePropertyName(node.propertyName)) { return; } @@ -725,6 +752,10 @@ module TypeScript { } public visitEnumElement(node: EnumElementSyntax): void { + if (this.checkForTemplatePropertyName(node.propertyName)) { + return; + } + if (this.inAmbientDeclaration && node.equalsValueClause) { var expression = node.equalsValueClause.value; if (!Syntax.isIntegerLiteral(expression)) { @@ -1311,6 +1342,14 @@ module TypeScript { super.visitFunctionExpression(node); } + public visitFunctionPropertyAssignment(node: FunctionPropertyAssignmentSyntax): void { + if (this.checkForTemplatePropertyName(node.propertyName)) { + return; + } + + super.visitFunctionPropertyAssignment(node); + } + public visitVariableStatement(node: VariableStatementSyntax): void { if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || @@ -1375,13 +1414,23 @@ module TypeScript { public visitVariableDeclarator(node: VariableDeclaratorSyntax): void { if (this.checkVariableDeclaratorInitializer(node) || - this.checkVariableDeclaratorIdentifier(node)) { + this.checkVariableDeclaratorIdentifier(node) || + this.checkForTemplatePropertyName(node.propertyName)) { return; } super.visitVariableDeclarator(node); } + private checkForTemplatePropertyName(token: ISyntaxToken): boolean { + if (token.kind() === SyntaxKind.NoSubstitutionTemplateToken) { + this.pushDiagnostic(token, DiagnosticCode.Template_literal_cannot_be_used_as_an_element_name); + return true; + } + + return false; + } + private checkVariableDeclaratorIdentifier(node: VariableDeclaratorSyntax): boolean { if (node.parent.kind() !== SyntaxKind.MemberVariableDeclaration) { if (this.checkForDisallowedEvalOrArguments(node, node.propertyName)) { diff --git a/src/services/syntax/syntaxUtilities.ts b/src/services/syntax/syntaxUtilities.ts index 406b4eafe5676..06525cf81b6e0 100644 --- a/src/services/syntax/syntaxUtilities.ts +++ b/src/services/syntax/syntaxUtilities.ts @@ -37,6 +37,7 @@ module TypeScript { switch (element.kind()) { case SyntaxKind.MemberAccessExpression: case SyntaxKind.ElementAccessExpression: + case SyntaxKind.TemplateAccessExpression: case SyntaxKind.ObjectCreationExpression: case SyntaxKind.InvocationExpression: case SyntaxKind.ArrayLiteralExpression: @@ -59,45 +60,6 @@ module TypeScript { return false; } - public static isExpression(element: ISyntaxElement) { - if (element) { - switch (element.kind()) { - case SyntaxKind.IdentifierName: - case SyntaxKind.RegularExpressionLiteral: - case SyntaxKind.NumericLiteral: - case SyntaxKind.StringLiteral: - case SyntaxKind.FalseKeyword: - case SyntaxKind.NullKeyword: - case SyntaxKind.ThisKeyword: - case SyntaxKind.TrueKeyword: - case SyntaxKind.SuperKeyword: - - case SyntaxKind.PrefixUnaryExpression: - case SyntaxKind.PostfixUnaryExpression: - case SyntaxKind.BinaryExpression: - case SyntaxKind.DeleteExpression: - case SyntaxKind.TypeOfExpression: - case SyntaxKind.VoidExpression: - case SyntaxKind.ConditionalExpression: - case SyntaxKind.MemberAccessExpression: - case SyntaxKind.InvocationExpression: - case SyntaxKind.ArrayLiteralExpression: - case SyntaxKind.ObjectLiteralExpression: - case SyntaxKind.ObjectCreationExpression: - case SyntaxKind.ParenthesizedExpression: - case SyntaxKind.ParenthesizedArrowFunctionExpression: - case SyntaxKind.SimpleArrowFunctionExpression: - case SyntaxKind.CastExpression: - case SyntaxKind.ElementAccessExpression: - case SyntaxKind.FunctionExpression: - case SyntaxKind.OmittedExpression: - return true; - } - } - - return false; - } - public static isSwitchClause(element: ISyntaxElement) { if (element) { switch (element.kind()) { diff --git a/src/services/syntax/syntaxVisitor.generated.ts b/src/services/syntax/syntaxVisitor.generated.ts index 6a38a81312b22..f0d50ed52639c 100644 --- a/src/services/syntax/syntaxVisitor.generated.ts +++ b/src/services/syntax/syntaxVisitor.generated.ts @@ -74,6 +74,8 @@ module TypeScript { visitElementAccessExpression(node: ElementAccessExpressionSyntax): any; visitFunctionExpression(node: FunctionExpressionSyntax): any; visitOmittedExpression(node: OmittedExpressionSyntax): any; + visitTemplateExpression(node: TemplateExpressionSyntax): any; + visitTemplateAccessExpression(node: TemplateAccessExpressionSyntax): any; visitVariableDeclaration(node: VariableDeclarationSyntax): any; visitVariableDeclarator(node: VariableDeclaratorSyntax): any; visitArgumentList(node: ArgumentListSyntax): any; @@ -87,6 +89,7 @@ module TypeScript { visitElseClause(node: ElseClauseSyntax): any; visitCatchClause(node: CatchClauseSyntax): any; visitFinallyClause(node: FinallyClauseSyntax): any; + visitTemplateClause(node: TemplateClauseSyntax): any; visitTypeParameter(node: TypeParameterSyntax): any; visitConstraint(node: ConstraintSyntax): any; visitSimplePropertyAssignment(node: SimplePropertyAssignmentSyntax): any; diff --git a/src/services/syntax/syntaxWalker.generated.ts b/src/services/syntax/syntaxWalker.generated.ts index 4122d8ce50990..675a572f4b705 100644 --- a/src/services/syntax/syntaxWalker.generated.ts +++ b/src/services/syntax/syntaxWalker.generated.ts @@ -476,6 +476,16 @@ module TypeScript { public visitOmittedExpression(node: OmittedExpressionSyntax): void { } + public visitTemplateExpression(node: TemplateExpressionSyntax): void { + this.visitToken(node.templateStartToken); + this.visitList(node.templateClauses); + } + + public visitTemplateAccessExpression(node: TemplateAccessExpressionSyntax): void { + node.expression.accept(this); + node.templateExpression.accept(this); + } + public visitVariableDeclaration(node: VariableDeclarationSyntax): void { this.visitToken(node.varKeyword); this.visitList(node.variableDeclarators); @@ -554,6 +564,11 @@ module TypeScript { node.block.accept(this); } + public visitTemplateClause(node: TemplateClauseSyntax): void { + node.expression.accept(this); + this.visitToken(node.templateMiddleOrEndToken); + } + public visitTypeParameter(node: TypeParameterSyntax): void { this.visitToken(node.identifier); this.visitOptionalNode(node.constraint); diff --git a/src/services/text/characterCodes.ts b/src/services/text/characterCodes.ts index 040e0c41c6b04..91d500f1749a4 100644 --- a/src/services/text/characterCodes.ts +++ b/src/services/text/characterCodes.ts @@ -104,6 +104,7 @@ module TypeScript { asterisk = 42, // * at = 64, // @ backslash = 92, // \ + backtick = 96, // ` bar = 124, // | caret = 94, // ^ closeBrace = 125, // }