diff --git a/src/services/formatting/indentationTrackingWalker.ts b/src/services/formatting/indentationTrackingWalker.ts index 60330872a865a..c8cc555d6f3fe 100644 --- a/src/services/formatting/indentationTrackingWalker.ts +++ b/src/services/formatting/indentationTrackingWalker.ts @@ -103,7 +103,7 @@ module TypeScript.Services.Formatting { if (isToken(element)) { this.visitToken(element); } - else if (element.kind() === SyntaxKind.List || element.kind() === SyntaxKind.SeparatedList) { + else if (element.kind() === SyntaxKind.List) { for (var i = 0, n = element.childCount(); i < n; i++) { this.walk(element.childAt(i)); } diff --git a/src/services/syntax/SyntaxGenerator.js b/src/services/syntax/SyntaxGenerator.js index b76b6a95098a6..5c912b9f8f5a3 100644 --- a/src/services/syntax/SyntaxGenerator.js +++ b/src/services/syntax/SyntaxGenerator.js @@ -411,212 +411,210 @@ var TypeScript; (function (SyntaxKind) { SyntaxKind[SyntaxKind["None"] = 0] = "None"; SyntaxKind[SyntaxKind["List"] = 1] = "List"; - SyntaxKind[SyntaxKind["SeparatedList"] = 2] = "SeparatedList"; - SyntaxKind[SyntaxKind["TriviaList"] = 3] = "TriviaList"; - SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 4] = "WhitespaceTrivia"; - SyntaxKind[SyntaxKind["NewLineTrivia"] = 5] = "NewLineTrivia"; - SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 6] = "MultiLineCommentTrivia"; - SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 7] = "SingleLineCommentTrivia"; - SyntaxKind[SyntaxKind["SkippedTokenTrivia"] = 8] = "SkippedTokenTrivia"; - SyntaxKind[SyntaxKind["ErrorToken"] = 9] = "ErrorToken"; - SyntaxKind[SyntaxKind["EndOfFileToken"] = 10] = "EndOfFileToken"; - SyntaxKind[SyntaxKind["IdentifierName"] = 11] = "IdentifierName"; - SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 12] = "RegularExpressionLiteral"; - SyntaxKind[SyntaxKind["NumericLiteral"] = 13] = "NumericLiteral"; - SyntaxKind[SyntaxKind["StringLiteral"] = 14] = "StringLiteral"; - SyntaxKind[SyntaxKind["BreakKeyword"] = 15] = "BreakKeyword"; - SyntaxKind[SyntaxKind["CaseKeyword"] = 16] = "CaseKeyword"; - SyntaxKind[SyntaxKind["CatchKeyword"] = 17] = "CatchKeyword"; - SyntaxKind[SyntaxKind["ContinueKeyword"] = 18] = "ContinueKeyword"; - SyntaxKind[SyntaxKind["DebuggerKeyword"] = 19] = "DebuggerKeyword"; - SyntaxKind[SyntaxKind["DefaultKeyword"] = 20] = "DefaultKeyword"; - SyntaxKind[SyntaxKind["DeleteKeyword"] = 21] = "DeleteKeyword"; - SyntaxKind[SyntaxKind["DoKeyword"] = 22] = "DoKeyword"; - SyntaxKind[SyntaxKind["ElseKeyword"] = 23] = "ElseKeyword"; - SyntaxKind[SyntaxKind["FalseKeyword"] = 24] = "FalseKeyword"; - SyntaxKind[SyntaxKind["FinallyKeyword"] = 25] = "FinallyKeyword"; - SyntaxKind[SyntaxKind["ForKeyword"] = 26] = "ForKeyword"; - SyntaxKind[SyntaxKind["FunctionKeyword"] = 27] = "FunctionKeyword"; - SyntaxKind[SyntaxKind["IfKeyword"] = 28] = "IfKeyword"; - SyntaxKind[SyntaxKind["InKeyword"] = 29] = "InKeyword"; - SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 30] = "InstanceOfKeyword"; - SyntaxKind[SyntaxKind["NewKeyword"] = 31] = "NewKeyword"; - SyntaxKind[SyntaxKind["NullKeyword"] = 32] = "NullKeyword"; - SyntaxKind[SyntaxKind["ReturnKeyword"] = 33] = "ReturnKeyword"; - SyntaxKind[SyntaxKind["SwitchKeyword"] = 34] = "SwitchKeyword"; - SyntaxKind[SyntaxKind["ThisKeyword"] = 35] = "ThisKeyword"; - SyntaxKind[SyntaxKind["ThrowKeyword"] = 36] = "ThrowKeyword"; - SyntaxKind[SyntaxKind["TrueKeyword"] = 37] = "TrueKeyword"; - SyntaxKind[SyntaxKind["TryKeyword"] = 38] = "TryKeyword"; - SyntaxKind[SyntaxKind["TypeOfKeyword"] = 39] = "TypeOfKeyword"; - SyntaxKind[SyntaxKind["VarKeyword"] = 40] = "VarKeyword"; - SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword"; - SyntaxKind[SyntaxKind["WhileKeyword"] = 42] = "WhileKeyword"; - SyntaxKind[SyntaxKind["WithKeyword"] = 43] = "WithKeyword"; - SyntaxKind[SyntaxKind["ClassKeyword"] = 44] = "ClassKeyword"; - SyntaxKind[SyntaxKind["ConstKeyword"] = 45] = "ConstKeyword"; - SyntaxKind[SyntaxKind["EnumKeyword"] = 46] = "EnumKeyword"; - SyntaxKind[SyntaxKind["ExportKeyword"] = 47] = "ExportKeyword"; - SyntaxKind[SyntaxKind["ExtendsKeyword"] = 48] = "ExtendsKeyword"; - SyntaxKind[SyntaxKind["ImportKeyword"] = 49] = "ImportKeyword"; - SyntaxKind[SyntaxKind["SuperKeyword"] = 50] = "SuperKeyword"; - SyntaxKind[SyntaxKind["ImplementsKeyword"] = 51] = "ImplementsKeyword"; - SyntaxKind[SyntaxKind["InterfaceKeyword"] = 52] = "InterfaceKeyword"; - SyntaxKind[SyntaxKind["LetKeyword"] = 53] = "LetKeyword"; - SyntaxKind[SyntaxKind["PackageKeyword"] = 54] = "PackageKeyword"; - SyntaxKind[SyntaxKind["PrivateKeyword"] = 55] = "PrivateKeyword"; - SyntaxKind[SyntaxKind["ProtectedKeyword"] = 56] = "ProtectedKeyword"; - SyntaxKind[SyntaxKind["PublicKeyword"] = 57] = "PublicKeyword"; - SyntaxKind[SyntaxKind["StaticKeyword"] = 58] = "StaticKeyword"; - SyntaxKind[SyntaxKind["YieldKeyword"] = 59] = "YieldKeyword"; - SyntaxKind[SyntaxKind["AnyKeyword"] = 60] = "AnyKeyword"; - SyntaxKind[SyntaxKind["BooleanKeyword"] = 61] = "BooleanKeyword"; - SyntaxKind[SyntaxKind["ConstructorKeyword"] = 62] = "ConstructorKeyword"; - SyntaxKind[SyntaxKind["DeclareKeyword"] = 63] = "DeclareKeyword"; - SyntaxKind[SyntaxKind["GetKeyword"] = 64] = "GetKeyword"; - SyntaxKind[SyntaxKind["ModuleKeyword"] = 65] = "ModuleKeyword"; - SyntaxKind[SyntaxKind["RequireKeyword"] = 66] = "RequireKeyword"; - SyntaxKind[SyntaxKind["NumberKeyword"] = 67] = "NumberKeyword"; - SyntaxKind[SyntaxKind["SetKeyword"] = 68] = "SetKeyword"; - SyntaxKind[SyntaxKind["StringKeyword"] = 69] = "StringKeyword"; - SyntaxKind[SyntaxKind["OpenBraceToken"] = 70] = "OpenBraceToken"; - SyntaxKind[SyntaxKind["CloseBraceToken"] = 71] = "CloseBraceToken"; - SyntaxKind[SyntaxKind["OpenParenToken"] = 72] = "OpenParenToken"; - SyntaxKind[SyntaxKind["CloseParenToken"] = 73] = "CloseParenToken"; - SyntaxKind[SyntaxKind["OpenBracketToken"] = 74] = "OpenBracketToken"; - SyntaxKind[SyntaxKind["CloseBracketToken"] = 75] = "CloseBracketToken"; - SyntaxKind[SyntaxKind["DotToken"] = 76] = "DotToken"; - SyntaxKind[SyntaxKind["DotDotDotToken"] = 77] = "DotDotDotToken"; - SyntaxKind[SyntaxKind["SemicolonToken"] = 78] = "SemicolonToken"; - SyntaxKind[SyntaxKind["CommaToken"] = 79] = "CommaToken"; - SyntaxKind[SyntaxKind["LessThanToken"] = 80] = "LessThanToken"; - SyntaxKind[SyntaxKind["GreaterThanToken"] = 81] = "GreaterThanToken"; - SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 82] = "LessThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 83] = "GreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 84] = "EqualsEqualsToken"; - SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 85] = "EqualsGreaterThanToken"; - SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 86] = "ExclamationEqualsToken"; - SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 87] = "EqualsEqualsEqualsToken"; - SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 88] = "ExclamationEqualsEqualsToken"; - SyntaxKind[SyntaxKind["PlusToken"] = 89] = "PlusToken"; - SyntaxKind[SyntaxKind["MinusToken"] = 90] = "MinusToken"; - SyntaxKind[SyntaxKind["AsteriskToken"] = 91] = "AsteriskToken"; - SyntaxKind[SyntaxKind["PercentToken"] = 92] = "PercentToken"; - SyntaxKind[SyntaxKind["PlusPlusToken"] = 93] = "PlusPlusToken"; - SyntaxKind[SyntaxKind["MinusMinusToken"] = 94] = "MinusMinusToken"; - SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 95] = "LessThanLessThanToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 96] = "GreaterThanGreaterThanToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 97] = "GreaterThanGreaterThanGreaterThanToken"; - SyntaxKind[SyntaxKind["AmpersandToken"] = 98] = "AmpersandToken"; - SyntaxKind[SyntaxKind["BarToken"] = 99] = "BarToken"; - SyntaxKind[SyntaxKind["CaretToken"] = 100] = "CaretToken"; - SyntaxKind[SyntaxKind["ExclamationToken"] = 101] = "ExclamationToken"; - SyntaxKind[SyntaxKind["TildeToken"] = 102] = "TildeToken"; - SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 103] = "AmpersandAmpersandToken"; - SyntaxKind[SyntaxKind["BarBarToken"] = 104] = "BarBarToken"; - SyntaxKind[SyntaxKind["QuestionToken"] = 105] = "QuestionToken"; - SyntaxKind[SyntaxKind["ColonToken"] = 106] = "ColonToken"; - SyntaxKind[SyntaxKind["EqualsToken"] = 107] = "EqualsToken"; - SyntaxKind[SyntaxKind["PlusEqualsToken"] = 108] = "PlusEqualsToken"; - SyntaxKind[SyntaxKind["MinusEqualsToken"] = 109] = "MinusEqualsToken"; - SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 110] = "AsteriskEqualsToken"; - SyntaxKind[SyntaxKind["PercentEqualsToken"] = 111] = "PercentEqualsToken"; - SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 112] = "LessThanLessThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 113] = "GreaterThanGreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 114] = "GreaterThanGreaterThanGreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 115] = "AmpersandEqualsToken"; - SyntaxKind[SyntaxKind["BarEqualsToken"] = 116] = "BarEqualsToken"; - SyntaxKind[SyntaxKind["CaretEqualsToken"] = 117] = "CaretEqualsToken"; - SyntaxKind[SyntaxKind["SlashToken"] = 118] = "SlashToken"; - SyntaxKind[SyntaxKind["SlashEqualsToken"] = 119] = "SlashEqualsToken"; - SyntaxKind[SyntaxKind["SourceUnit"] = 120] = "SourceUnit"; - SyntaxKind[SyntaxKind["QualifiedName"] = 121] = "QualifiedName"; - SyntaxKind[SyntaxKind["ObjectType"] = 122] = "ObjectType"; - SyntaxKind[SyntaxKind["FunctionType"] = 123] = "FunctionType"; - SyntaxKind[SyntaxKind["ArrayType"] = 124] = "ArrayType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 125] = "ConstructorType"; - SyntaxKind[SyntaxKind["GenericType"] = 126] = "GenericType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 127] = "TypeQuery"; - SyntaxKind[SyntaxKind["TupleType"] = 128] = "TupleType"; - SyntaxKind[SyntaxKind["UnionType"] = 129] = "UnionType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 130] = "ParenthesizedType"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 131] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 132] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 133] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 134] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 135] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 136] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 137] = "ExportAssignment"; - SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 138] = "MemberFunctionDeclaration"; - SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 139] = "MemberVariableDeclaration"; - SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 140] = "ConstructorDeclaration"; - SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 141] = "IndexMemberDeclaration"; - SyntaxKind[SyntaxKind["GetAccessor"] = 142] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 143] = "SetAccessor"; - SyntaxKind[SyntaxKind["PropertySignature"] = 144] = "PropertySignature"; - SyntaxKind[SyntaxKind["CallSignature"] = 145] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 146] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 147] = "IndexSignature"; - SyntaxKind[SyntaxKind["MethodSignature"] = 148] = "MethodSignature"; - SyntaxKind[SyntaxKind["Block"] = 149] = "Block"; - SyntaxKind[SyntaxKind["IfStatement"] = 150] = "IfStatement"; - SyntaxKind[SyntaxKind["VariableStatement"] = 151] = "VariableStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 152] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 153] = "ReturnStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 154] = "SwitchStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 155] = "BreakStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 156] = "ContinueStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 157] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 158] = "ForInStatement"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 159] = "EmptyStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 160] = "ThrowStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 161] = "WhileStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 162] = "TryStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 163] = "LabeledStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 164] = "DoStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 165] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 166] = "WithStatement"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 167] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 168] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 169] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 170] = "VoidExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 171] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 172] = "BinaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 173] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["MemberAccessExpression"] = 174] = "MemberAccessExpression"; - SyntaxKind[SyntaxKind["InvocationExpression"] = 175] = "InvocationExpression"; - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 176] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 177] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 178] = "ObjectCreationExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 179] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 180] = "ParenthesizedArrowFunctionExpression"; - SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 181] = "SimpleArrowFunctionExpression"; - SyntaxKind[SyntaxKind["CastExpression"] = 182] = "CastExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 183] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 184] = "FunctionExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 185] = "OmittedExpression"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 186] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarator"] = 187] = "VariableDeclarator"; - SyntaxKind[SyntaxKind["ArgumentList"] = 188] = "ArgumentList"; - SyntaxKind[SyntaxKind["ParameterList"] = 189] = "ParameterList"; - SyntaxKind[SyntaxKind["TypeArgumentList"] = 190] = "TypeArgumentList"; - SyntaxKind[SyntaxKind["TypeParameterList"] = 191] = "TypeParameterList"; - SyntaxKind[SyntaxKind["HeritageClause"] = 192] = "HeritageClause"; - SyntaxKind[SyntaxKind["EqualsValueClause"] = 193] = "EqualsValueClause"; - SyntaxKind[SyntaxKind["CaseSwitchClause"] = 194] = "CaseSwitchClause"; - SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 195] = "DefaultSwitchClause"; - SyntaxKind[SyntaxKind["ElseClause"] = 196] = "ElseClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 197] = "CatchClause"; - SyntaxKind[SyntaxKind["FinallyClause"] = 198] = "FinallyClause"; - SyntaxKind[SyntaxKind["TypeParameter"] = 199] = "TypeParameter"; - SyntaxKind[SyntaxKind["Constraint"] = 200] = "Constraint"; - SyntaxKind[SyntaxKind["SimplePropertyAssignment"] = 201] = "SimplePropertyAssignment"; - SyntaxKind[SyntaxKind["FunctionPropertyAssignment"] = 202] = "FunctionPropertyAssignment"; - SyntaxKind[SyntaxKind["Parameter"] = 203] = "Parameter"; - SyntaxKind[SyntaxKind["EnumElement"] = 204] = "EnumElement"; - SyntaxKind[SyntaxKind["TypeAnnotation"] = 205] = "TypeAnnotation"; - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 206] = "ExternalModuleReference"; - SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 207] = "ModuleNameModuleReference"; + SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 2] = "WhitespaceTrivia"; + SyntaxKind[SyntaxKind["NewLineTrivia"] = 3] = "NewLineTrivia"; + SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 4] = "MultiLineCommentTrivia"; + SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 5] = "SingleLineCommentTrivia"; + SyntaxKind[SyntaxKind["SkippedTokenTrivia"] = 6] = "SkippedTokenTrivia"; + SyntaxKind[SyntaxKind["ErrorToken"] = 7] = "ErrorToken"; + SyntaxKind[SyntaxKind["EndOfFileToken"] = 8] = "EndOfFileToken"; + SyntaxKind[SyntaxKind["IdentifierName"] = 9] = "IdentifierName"; + 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["FirstStandardKeyword"] = SyntaxKind.BreakKeyword] = "FirstStandardKeyword"; SyntaxKind[SyntaxKind["LastStandardKeyword"] = SyntaxKind.WithKeyword] = "LastStandardKeyword"; SyntaxKind[SyntaxKind["FirstFutureReservedKeyword"] = SyntaxKind.ClassKeyword] = "FirstFutureReservedKeyword"; @@ -645,111 +643,111 @@ var TypeScript; var SyntaxFacts; (function (SyntaxFacts) { var textToKeywordKind = { - "any": 60 /* AnyKeyword */, - "boolean": 61 /* BooleanKeyword */, - "break": 15 /* BreakKeyword */, - "case": 16 /* CaseKeyword */, - "catch": 17 /* CatchKeyword */, - "class": 44 /* ClassKeyword */, - "continue": 18 /* ContinueKeyword */, - "const": 45 /* ConstKeyword */, - "constructor": 62 /* ConstructorKeyword */, - "debugger": 19 /* DebuggerKeyword */, - "declare": 63 /* DeclareKeyword */, - "default": 20 /* DefaultKeyword */, - "delete": 21 /* DeleteKeyword */, - "do": 22 /* DoKeyword */, - "else": 23 /* ElseKeyword */, - "enum": 46 /* EnumKeyword */, - "export": 47 /* ExportKeyword */, - "extends": 48 /* ExtendsKeyword */, - "false": 24 /* FalseKeyword */, - "finally": 25 /* FinallyKeyword */, - "for": 26 /* ForKeyword */, - "function": 27 /* FunctionKeyword */, - "get": 64 /* GetKeyword */, - "if": 28 /* IfKeyword */, - "implements": 51 /* ImplementsKeyword */, - "import": 49 /* ImportKeyword */, - "in": 29 /* InKeyword */, - "instanceof": 30 /* InstanceOfKeyword */, - "interface": 52 /* InterfaceKeyword */, - "let": 53 /* LetKeyword */, - "module": 65 /* ModuleKeyword */, - "new": 31 /* NewKeyword */, - "null": 32 /* NullKeyword */, - "number": 67 /* NumberKeyword */, - "package": 54 /* PackageKeyword */, - "private": 55 /* PrivateKeyword */, - "protected": 56 /* ProtectedKeyword */, - "public": 57 /* PublicKeyword */, - "require": 66 /* RequireKeyword */, - "return": 33 /* ReturnKeyword */, - "set": 68 /* SetKeyword */, - "static": 58 /* StaticKeyword */, - "string": 69 /* StringKeyword */, - "super": 50 /* SuperKeyword */, - "switch": 34 /* SwitchKeyword */, - "this": 35 /* ThisKeyword */, - "throw": 36 /* ThrowKeyword */, - "true": 37 /* TrueKeyword */, - "try": 38 /* TryKeyword */, - "typeof": 39 /* TypeOfKeyword */, - "var": 40 /* VarKeyword */, - "void": 41 /* VoidKeyword */, - "while": 42 /* WhileKeyword */, - "with": 43 /* WithKeyword */, - "yield": 59 /* YieldKeyword */, - "{": 70 /* OpenBraceToken */, - "}": 71 /* CloseBraceToken */, - "(": 72 /* OpenParenToken */, - ")": 73 /* CloseParenToken */, - "[": 74 /* OpenBracketToken */, - "]": 75 /* CloseBracketToken */, - ".": 76 /* DotToken */, - "...": 77 /* DotDotDotToken */, - ";": 78 /* SemicolonToken */, - ",": 79 /* CommaToken */, - "<": 80 /* LessThanToken */, - ">": 81 /* GreaterThanToken */, - "<=": 82 /* LessThanEqualsToken */, - ">=": 83 /* GreaterThanEqualsToken */, - "==": 84 /* EqualsEqualsToken */, - "=>": 85 /* EqualsGreaterThanToken */, - "!=": 86 /* ExclamationEqualsToken */, - "===": 87 /* EqualsEqualsEqualsToken */, - "!==": 88 /* ExclamationEqualsEqualsToken */, - "+": 89 /* PlusToken */, - "-": 90 /* MinusToken */, - "*": 91 /* AsteriskToken */, - "%": 92 /* PercentToken */, - "++": 93 /* PlusPlusToken */, - "--": 94 /* MinusMinusToken */, - "<<": 95 /* LessThanLessThanToken */, - ">>": 96 /* GreaterThanGreaterThanToken */, - ">>>": 97 /* GreaterThanGreaterThanGreaterThanToken */, - "&": 98 /* AmpersandToken */, - "|": 99 /* BarToken */, - "^": 100 /* CaretToken */, - "!": 101 /* ExclamationToken */, - "~": 102 /* TildeToken */, - "&&": 103 /* AmpersandAmpersandToken */, - "||": 104 /* BarBarToken */, - "?": 105 /* QuestionToken */, - ":": 106 /* ColonToken */, - "=": 107 /* EqualsToken */, - "+=": 108 /* PlusEqualsToken */, - "-=": 109 /* MinusEqualsToken */, - "*=": 110 /* AsteriskEqualsToken */, - "%=": 111 /* PercentEqualsToken */, - "<<=": 112 /* LessThanLessThanEqualsToken */, - ">>=": 113 /* GreaterThanGreaterThanEqualsToken */, - ">>>=": 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */, - "&=": 115 /* AmpersandEqualsToken */, - "|=": 116 /* BarEqualsToken */, - "^=": 117 /* CaretEqualsToken */, - "/": 118 /* SlashToken */, - "/=": 119 /* SlashEqualsToken */ + "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 */ }; var kindToText = new Array(); for (var name in textToKeywordKind) { @@ -757,7 +755,7 @@ var TypeScript; kindToText[textToKeywordKind[name]] = name; } } - kindToText[62 /* ConstructorKeyword */] = "constructor"; + kindToText[60 /* ConstructorKeyword */] = "constructor"; function getTokenKind(text) { if (textToKeywordKind.hasOwnProperty(text)) { return textToKeywordKind[text]; @@ -780,12 +778,12 @@ var TypeScript; SyntaxFacts.isAnyPunctuation = isAnyPunctuation; function isPrefixUnaryExpressionOperatorToken(tokenKind) { switch (tokenKind) { - case 89 /* PlusToken */: - case 90 /* MinusToken */: - case 102 /* TildeToken */: - case 101 /* ExclamationToken */: - case 93 /* PlusPlusToken */: - case 94 /* MinusMinusToken */: + case 87 /* PlusToken */: + case 88 /* MinusToken */: + case 100 /* TildeToken */: + case 99 /* ExclamationToken */: + case 91 /* PlusPlusToken */: + case 92 /* MinusMinusToken */: return true; default: return false; @@ -794,42 +792,42 @@ var TypeScript; SyntaxFacts.isPrefixUnaryExpressionOperatorToken = isPrefixUnaryExpressionOperatorToken; function isBinaryExpressionOperatorToken(tokenKind) { switch (tokenKind) { - case 91 /* AsteriskToken */: - case 118 /* SlashToken */: - case 92 /* PercentToken */: - case 89 /* PlusToken */: - case 90 /* MinusToken */: - case 95 /* LessThanLessThanToken */: - case 96 /* GreaterThanGreaterThanToken */: - case 97 /* GreaterThanGreaterThanGreaterThanToken */: - case 80 /* LessThanToken */: - case 81 /* GreaterThanToken */: - case 82 /* LessThanEqualsToken */: - case 83 /* GreaterThanEqualsToken */: - case 30 /* InstanceOfKeyword */: - case 29 /* InKeyword */: - case 84 /* EqualsEqualsToken */: - case 86 /* ExclamationEqualsToken */: - case 87 /* EqualsEqualsEqualsToken */: - case 88 /* ExclamationEqualsEqualsToken */: - case 98 /* AmpersandToken */: - case 100 /* CaretToken */: - case 99 /* BarToken */: - case 103 /* AmpersandAmpersandToken */: - case 104 /* BarBarToken */: - case 116 /* BarEqualsToken */: - case 115 /* AmpersandEqualsToken */: - case 117 /* CaretEqualsToken */: - case 112 /* LessThanLessThanEqualsToken */: - case 113 /* GreaterThanGreaterThanEqualsToken */: - case 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */: - case 108 /* PlusEqualsToken */: - case 109 /* MinusEqualsToken */: - case 110 /* AsteriskEqualsToken */: - case 119 /* SlashEqualsToken */: - case 111 /* PercentEqualsToken */: - case 107 /* EqualsToken */: - case 79 /* CommaToken */: + 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 */: return true; default: return false; @@ -838,18 +836,18 @@ var TypeScript; SyntaxFacts.isBinaryExpressionOperatorToken = isBinaryExpressionOperatorToken; function isAssignmentOperatorToken(tokenKind) { switch (tokenKind) { - case 116 /* BarEqualsToken */: - case 115 /* AmpersandEqualsToken */: - case 117 /* CaretEqualsToken */: - case 112 /* LessThanLessThanEqualsToken */: - case 113 /* GreaterThanGreaterThanEqualsToken */: - case 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */: - case 108 /* PlusEqualsToken */: - case 109 /* MinusEqualsToken */: - case 110 /* AsteriskEqualsToken */: - case 119 /* SlashEqualsToken */: - case 111 /* PercentEqualsToken */: - case 107 /* EqualsToken */: + 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 */: return true; default: return false; @@ -858,19 +856,19 @@ var TypeScript; SyntaxFacts.isAssignmentOperatorToken = isAssignmentOperatorToken; function isType(kind) { switch (kind) { - case 124 /* ArrayType */: - case 60 /* AnyKeyword */: - case 67 /* NumberKeyword */: - case 61 /* BooleanKeyword */: - case 69 /* StringKeyword */: - case 41 /* VoidKeyword */: - case 123 /* FunctionType */: - case 122 /* ObjectType */: - case 125 /* ConstructorType */: - case 127 /* TypeQuery */: - case 126 /* GenericType */: - case 121 /* QualifiedName */: - case 11 /* IdentifierName */: + 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 9 /* IdentifierName */: return true; } return false; @@ -878,166 +876,6 @@ var TypeScript; SyntaxFacts.isType = isType; })(SyntaxFacts = TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {})); })(TypeScript || (TypeScript = {})); -if (!String.prototype.trim) { - String.prototype.trim = function () { - return this.replace(/^\s+|\s+$/g, ''); - }; -} -if (!Array.prototype.indexOf) { - Array.prototype.indexOf = function (searchElement, fromIndex) { - "use strict"; - if (this == null) { - throw new TypeError(); - } - var t = Object(this); - var len = t.length >>> 0; - if (len === 0) { - return -1; - } - var n = 0; - if (arguments.length > 0) { - n = Number(arguments[1]); - if (n != n) { - n = 0; - } - else if (n != 0 && n != Infinity && n != -Infinity) { - n = (n > 0 || -1) * Math.floor(Math.abs(n)); - } - } - if (n >= len) { - return -1; - } - var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0); - for (; k < len; k++) { - if (k in t && t[k] === searchElement) { - return k; - } - } - return -1; - }; -} -if (!Array.prototype.filter) { - Array.prototype.filter = function (fun, thisp) { - "use strict"; - if (this == null) - throw new TypeError(); - var t = Object(this); - var len = t.length >>> 0; - if (typeof fun != "function") - throw new TypeError(); - var res = []; - for (var i = 0; i < len; i++) { - if (i in t) { - var val = t[i]; - if (fun.call(thisp, val, i, t)) - res.push(val); - } - } - return res; - }; -} -if (!Array.prototype.map) { - Array.prototype.map = function (callback, thisArg) { - var T = undefined, A, k; - if (this == null) { - throw new TypeError(" this is null or not defined"); - } - var O = Object(this); - var len = O.length >>> 0; - if ({}.toString.call(callback) != "[object Function]") { - throw new TypeError(callback + " is not a function"); - } - if (thisArg) { - T = thisArg; - } - A = new Array(len); - k = 0; - while (k < len) { - var kValue, mappedValue; - if (k in O) { - kValue = O[k]; - mappedValue = callback.call(T, kValue, k, O); - A[k] = mappedValue; - } - k++; - } - return A; - }; -} -if (!Array.prototype.reduce) { - Array.prototype.reduce = function reduce(accumulator) { - if (this === null || this === undefined) - throw new TypeError("Object is null or undefined"); - var i = 0, l = this.length >> 0, curr; - if (typeof accumulator !== "function") - throw new TypeError("First argument is not callable"); - if (arguments.length < 2) { - if (l === 0) - throw new TypeError("Array length is 0 and no second argument"); - curr = this[0]; - i = 1; - } - else - curr = arguments[1]; - while (i < l) { - if (i in this) - curr = accumulator.call(undefined, curr, this[i], i, this); - ++i; - } - return curr; - }; -} -if (!Array.prototype.forEach) { - Array.prototype.forEach = function (callback, thisArg) { - var T, k; - if (this == null) { - throw new TypeError(" this is null or not defined"); - } - var O = Object(this); - var len = O.length >>> 0; - if ({}.toString.call(callback) != "[object Function]") { - throw new TypeError(callback + " is not a function"); - } - if (thisArg) { - T = thisArg; - } - else { - T = undefined; - } - k = 0; - while (k < len) { - var kValue; - if (k in O) { - kValue = O[k]; - callback.call(T, kValue, k, O); - } - k++; - } - }; -} -if (!Date.now) { - Date.now = function () { - return (new Date()).getTime(); - }; -} -if (!Array.prototype.some) { - Array.prototype.some = function (fun) { - "use strict"; - if (this == null) - throw new TypeError(); - var t = Object(this); - var len = t.length >>> 0; - if (typeof fun != "function") - throw new TypeError(); - var thisp = arguments[1]; - for (var i = 0; i < len; i++) { - var idx = i.toString(); - if (idx in t && fun.call(thisp, t[i], i, t)) - return true; - } - return false; - }; -} var argumentChecks = false; var forPrettyPrinter = false; var interfaces = { @@ -2026,7 +1864,7 @@ function getType(child) { return "ISyntaxToken"; } else if (child.isSeparatedList) { - return child.elementType + "[]"; + return "ISeparatedSyntaxList<" + child.elementType + ">"; } else if (child.isList) { return child.elementType + "[]"; @@ -2820,7 +2658,7 @@ function isNodeOrToken(child) { } function generateRewriter() { var result = "///\r\n\r\n"; - result += "module TypeScript {\r\n" + " export class SyntaxRewriter implements ISyntaxVisitor {\r\n" + " public visitToken(token: ISyntaxToken): ISyntaxToken {\r\n" + " return token;\r\n" + " }\r\n" + "\r\n" + " public visitNode(node: ISyntaxNode): ISyntaxNode {\r\n" + " return visitNodeOrToken(this, node);\r\n" + " }\r\n" + "\r\n" + " public visitNodeOrToken(node: ISyntaxNodeOrToken): ISyntaxNodeOrToken {\r\n" + " return isToken(node) ? this.visitToken(node) : this.visitNode(node);\r\n" + " }\r\n" + "\r\n" + " public visitList(list: T[]): T[] {\r\n" + " var newItems: T[] = undefined;\r\n" + "\r\n" + " for (var i = 0, n = list.length; i < n; i++) {\r\n" + " var item = list[i];\r\n" + " var newItem = this.visitNodeOrToken(item);\r\n" + "\r\n" + " if (item !== newItem && !newItems) {\r\n" + " newItems = [];\r\n" + " for (var j = 0; j < i; j++) {\r\n" + " newItems.push(list[j]);\r\n" + " }\r\n" + " }\r\n" + "\r\n" + " if (newItems) {\r\n" + " newItems.push(newItem);\r\n" + " }\r\n" + " }\r\n" + "\r\n" + " // Debug.assert(!newItems || newItems.length === childCount(list));\r\n" + " return !newItems ? list : Syntax.list(newItems);\r\n" + " }\r\n" + "\r\n" + " public visitSeparatedList(list: T[]): T[] {\r\n" + " var newItems: ISyntaxNodeOrToken[] = undefined;\r\n" + "\r\n" + " for (var i = 0, n = childCount(list); i < n; i++) {\r\n" + " var item = childAt(list, i);\r\n" + " var newItem = isToken(item) ? this.visitToken(item) : this.visitNode(item);\r\n" + "\r\n" + " if (item !== newItem && !newItems) {\r\n" + " newItems = [];\r\n" + " for (var j = 0; j < i; j++) {\r\n" + " newItems.push(childAt(list, j));\r\n" + " }\r\n" + " }\r\n" + "\r\n" + " if (newItems) {\r\n" + " newItems.push(newItem);\r\n" + " }\r\n" + " }\r\n" + "\r\n" + " // Debug.assert(newItems === undefined || newItems.length === childCount(list));\r\n" + " return !newItems ? list : Syntax.separatedList(newItems);\r\n" + " }\r\n"; + result += "module TypeScript {\r\n" + " export class SyntaxRewriter implements ISyntaxVisitor {\r\n" + " public visitToken(token: ISyntaxToken): ISyntaxToken {\r\n" + " return token;\r\n" + " }\r\n" + "\r\n" + " public visitNode(node: ISyntaxNode): ISyntaxNode {\r\n" + " return visitNodeOrToken(this, node);\r\n" + " }\r\n" + "\r\n" + " public visitNodeOrToken(node: ISyntaxNodeOrToken): ISyntaxNodeOrToken {\r\n" + " return isToken(node) ? this.visitToken(node) : this.visitNode(node);\r\n" + " }\r\n" + "\r\n" + " public visitList(list: T): T {\r\n" + " var newItems: T = undefined;\r\n" + "\r\n" + " for (var i = 0, n = list.length; i < n; i++) {\r\n" + " var item = list[i];\r\n" + " var newItem = this.visitNodeOrToken(item);\r\n" + "\r\n" + " if (item !== newItem && !newItems) {\r\n" + " newItems = [];\r\n" + " for (var j = 0; j < i; j++) {\r\n" + " newItems.push(list[j]);\r\n" + " }\r\n" + " }\r\n" + "\r\n" + " if (newItems) {\r\n" + " newItems.push(newItem);\r\n" + " }\r\n" + " }\r\n" + "\r\n" + " // Debug.assert(!newItems || newItems.length === childCount(list));\r\n" + " return !newItems ? list : Syntax.list(newItems);\r\n" + " }\r\n" + "\r\n"; for (var i = 0; i < definitions.length; i++) { var definition = definitions[i]; result += "\r\n"; @@ -2840,12 +2678,9 @@ function generateRewriter() { if (child.isToken) { result += "this.visitToken(node." + child.name + ")"; } - else if (child.isList) { + else if (child.isList || child.isSeparatedList) { result += "this.visitList(node." + child.name + ")"; } - else if (child.isSeparatedList) { - result += "this.visitSeparatedList(node." + child.name + ")"; - } else if (child.type === "SyntaxKind") { result += "node.kind"; } @@ -2868,7 +2703,7 @@ function generateRewriter() { } function generateWalker() { var result = ""; - result += "///\r\n" + "\r\n" + "module TypeScript {\r\n" + " export class SyntaxWalker implements ISyntaxVisitor {\r\n" + " public visitToken(token: ISyntaxToken): void {\r\n" + " }\r\n" + "\r\n" + " private visitOptionalToken(token: ISyntaxToken): void {\r\n" + " if (token === undefined) {\r\n" + " return;\r\n" + " }\r\n" + "\r\n" + " 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" + " list[i].accept(this);\r\n" + " }\r\n" + " }\r\n" + "\r\n" + " public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {\r\n" + " for (var i = 0, n = list.separatedListLength; 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"; + result += "///\r\n" + "\r\n" + "module TypeScript {\r\n" + " export class SyntaxWalker implements ISyntaxVisitor {\r\n" + " public visitToken(token: ISyntaxToken): void {\r\n" + " }\r\n" + "\r\n" + " private visitOptionalToken(token: ISyntaxToken): void {\r\n" + " if (token === undefined) {\r\n" + " return;\r\n" + " }\r\n" + "\r\n" + " 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" + " list[i].accept(this);\r\n" + " }\r\n" + " }\r\n" + "\r\n"; for (var i = 0; i < definitions.length; i++) { var definition = definitions[i]; result += "\r\n"; @@ -2883,12 +2718,9 @@ function generateWalker() { result += " this.visitToken(node." + child.name + ");\r\n"; } } - else if (child.isList) { + else if (child.isList || child.isSeparatedList) { result += " this.visitList(node." + child.name + ");\r\n"; } - else if (child.isSeparatedList) { - result += " this.visitSeparatedList(node." + child.name + ");\r\n"; - } else if (isNodeOrToken(child)) { if (child.isOptional) { result += " visitNodeOrToken(this, node." + child.name + ");\r\n"; @@ -3140,14 +2972,6 @@ function generateServicesUtilities() { function generateIsTypeScriptSpecific() { var result = ""; result += "module TypeScript {\r\n"; - result += " function isSeparatedListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\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"; - result += " return false;\r\n"; - result += " }\r\n\r\n"; result += " function isListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\r\n"; result += " for (var i = 0, n = list.length; i < n; i++) {\r\n"; result += " if (isTypeScriptSpecific(list[i])) {\r\n"; @@ -3160,7 +2984,6 @@ function generateIsTypeScriptSpecific() { result += " if (!element) { return false; }\r\n"; result += " if (isToken(element)) { return false; }\r\n"; result += " if (isList(element)) { return isListTypeScriptSpecific(element); }\r\n"; - result += " if (isSeparatedList(element)) { return isSeparatedListTypeScriptSpecific(element); }\r\n\r\n"; result += " switch (element.kind()) {\r\n"; for (var i = 0; i < definitions.length; i++) { var definition = definitions[i]; @@ -3245,12 +3068,9 @@ function generateIsTypeScriptSpecificMethod(definition) { } addedCheck = true; if (child.isTypeScriptSpecific) { - if (child.isList) { + if (child.isList || child.isSeparatedList) { result += getPropertyAccess(child, "node") + ".length > 0"; } - else if (child.isSeparatedList) { - result += getPropertyAccess(child, "node") + ".childCount() > 0"; - } else { result += "!!" + getPropertyAccess(child, "node"); } diff --git a/src/services/syntax/incrementalParser.ts b/src/services/syntax/incrementalParser.ts index 29bdfefc23c64..834a5696c62e8 100644 --- a/src/services/syntax/incrementalParser.ts +++ b/src/services/syntax/incrementalParser.ts @@ -777,7 +777,7 @@ module TypeScript.IncrementalParser { function moveToFirstChildIfList(): void { var element = pieces[currentPieceIndex].element; - if (isList(element) || isSeparatedList(element)) { + if (isList(element)) { // We cannot ever get an empty list in our piece path. Empty lists are 'shared' and // we make sure to filter that out before pushing any children. // Debug.assert(childCount(element) > 0); diff --git a/src/services/syntax/parser.ts b/src/services/syntax/parser.ts index b67d56e636e18..bae8ce1ad8928 100644 --- a/src/services/syntax/parser.ts +++ b/src/services/syntax/parser.ts @@ -557,7 +557,7 @@ module TypeScript.Parser { // when next requested. while (true) { // Parent must be a list or a node. All of those have a 'data' element. - Debug.assert(isNode(parent) || isList(parent) || isSeparatedList(parent)); + Debug.assert(isNode(parent) || isList(parent)); var dataElement = <{ data: number }>parent; if (dataElement.data) { dataElement.data &= SyntaxConstants.NodeParsedInStrictModeMask @@ -592,20 +592,6 @@ module TypeScript.Parser { } } } - else if (isSeparatedList(parent)) { - var list2 = parent; - for (var i = 0, n = list2.childCount(); i < n; i++) { - if (list2.childAt(i) === oldToken) { - if (i % 2 === 0) { - list2[i / 2] = newToken; - } - else { - list2.separators[(i - 1) / 2] = newToken; - } - return; - } - } - } throw Errors.invalidOperation(); } @@ -3786,7 +3772,7 @@ module TypeScript.Parser { return result; } - function parseSeparatedSyntaxList(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): T[] { + function parseSeparatedSyntaxList(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): ISeparatedSyntaxList { var savedListParsingState = listParsingState; listParsingState |= (1 << currentListType); @@ -3799,7 +3785,7 @@ module TypeScript.Parser { // Returns true if we should abort parsing. function abortParsingListOrMoveToNextToken( - currentListType: ListParsingState, nodes: T[], separators: ISyntaxToken[], skippedTokens: ISyntaxToken[]): boolean { + currentListType: ListParsingState, nodeAndSeparators: ISyntaxNodeOrToken[], skippedTokens: ISyntaxToken[]): boolean { // Ok. We're at a token that is not a terminator for the list and wasn't the start of // an item in the list. Definitely report an error for this token. reportUnexpectedTokenDiagnostic(currentListType); @@ -3819,30 +3805,27 @@ module TypeScript.Parser { // Otherwise, if none of the lists we're in can capture this token, then we need to // unilaterally skip it. Note: we've already reported an error above. - addSkippedTokenToList(nodes, separators, skippedTokens, consumeToken(currentToken())); + addSkippedTokenToList(nodeAndSeparators, skippedTokens, consumeToken(currentToken())); // Continue parsing this list. Attach this token to whatever we've seen already. return false; } - function addSkippedTokenToList( - nodes: T[], separators: ISyntaxToken[], skippedTokens: ISyntaxToken[], skippedToken: ISyntaxToken): void { + function addSkippedTokenToList( + nodesAndSeparators: ISyntaxNodeOrToken[], skippedTokens: ISyntaxToken[], skippedToken: ISyntaxToken): void { // Now, add this skipped token to the last item we successfully parsed in the list. Or // add it to the list of skipped tokens if we haven't parsed anything. Our caller will // have to deal with them. // // Note: we only bother doing this if we're creating a concrete syntax tree. if (syntaxFactory.isConcrete) { - var length = nodes.length + (separators ? separators.length : 0); + var length = nodesAndSeparators.length; for (var i = length - 1; i >= 0; i--) { - var array: ISyntaxNodeOrToken[] = separators && (i % 2 === 1) ? separators : nodes; - var arrayIndex = separators ? IntegerUtilities.integerDivide(i, 2) : i; - - var item = array[arrayIndex]; + var item = nodesAndSeparators[i]; var _lastToken = lastToken(item); if (_lastToken && _lastToken.fullWidth() > 0) { - array[arrayIndex] = addSkippedTokenAfterNodeOrToken(item, skippedToken); + nodesAndSeparators[i] = addSkippedTokenAfterNodeOrToken(item, skippedToken); return; } } @@ -3895,7 +3878,7 @@ module TypeScript.Parser { // List wasn't complete and we didn't get an item. Figure out if we should bail out // or skip a token and continue. - var abort = abortParsingListOrMoveToNextToken(currentListType, items, /*separators:*/ undefined, skippedTokens); + var abort = abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens); if (abort) { break; } @@ -3914,9 +3897,8 @@ module TypeScript.Parser { return result; } - function parseSeparatedSyntaxListWorker(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): T[] { - var nodes: T[] = getArray(); - var separators: ISyntaxToken[] = getArray(); + function parseSeparatedSyntaxListWorker(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): ISeparatedSyntaxList { + var nodesAndSeparators: ISyntaxNodeOrToken[] = getArray(); // Debug.assert(nodes.length === 0); // Debug.assert(separators.length === 0); @@ -3934,7 +3916,7 @@ module TypeScript.Parser { // continue parsing. // Debug.assert(oldItemsCount % 2 === 0); - var succeeded = tryParseExpectedListItem(currentListType, inErrorRecovery, nodes, /*processItems:*/ undefined); + var succeeded = tryParseExpectedListItem(currentListType, inErrorRecovery, nodesAndSeparators, /*processItems:*/ undefined); if (!succeeded) { // We weren't able to parse out a list element. @@ -3948,7 +3930,7 @@ module TypeScript.Parser { // List wasn't complete and we didn't get an item. Figure out if we should bail out // or skip a token and continue. - var abort = abortParsingListOrMoveToNextToken(currentListType, nodes, separators, skippedTokens); + var abort = abortParsingListOrMoveToNextToken(currentListType, nodesAndSeparators, skippedTokens); if (abort) { break; } @@ -3973,7 +3955,7 @@ module TypeScript.Parser { var tokenKind = _currentToken.kind(); if (tokenKind === _separatorKind || tokenKind === SyntaxKind.CommaToken) { // Consume the last separator and continue parsing list elements. - separators.push(consumeToken(_currentToken)); + nodesAndSeparators.push(consumeToken(_currentToken)); continue; } @@ -4001,7 +3983,7 @@ module TypeScript.Parser { if (allowAutomaticSemicolonInsertion && canEatAutomaticSemicolon(/*allowWithoutNewline:*/ false)) { var semicolonToken = eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false) || Syntax.emptyToken(SyntaxKind.SemicolonToken); - separators.push(semicolonToken); + nodesAndSeparators.push(semicolonToken); // Debug.assert(items.length % 2 === 0); continue; } @@ -4011,7 +3993,7 @@ module TypeScript.Parser { // This time mark that we're in error recovery mode though. // // Note: trying to eat this token will emit the appropriate diagnostic. - separators.push(eatToken(_separatorKind)); + nodesAndSeparators.push(eatToken(_separatorKind)); // Now that we're in 'error recovery' mode we cantweak some parsing rules as // appropriate. For example, if we have: @@ -4027,12 +4009,11 @@ module TypeScript.Parser { inErrorRecovery = true; } - var result = Syntax.separatedList(nodes, separators); + var result = Syntax.separatedList(nodesAndSeparators); // Can't return if it has more then 0 elements. In that case, the list will have been // copied into the SyntaxList. - returnZeroLengthArray(nodes); - returnZeroLengthArray(separators); + returnZeroLengthArray(nodesAndSeparators); return result; } diff --git a/src/services/syntax/syntaxElement.ts b/src/services/syntax/syntaxElement.ts index 283307281d00c..7b5498d6550fe 100644 --- a/src/services/syntax/syntaxElement.ts +++ b/src/services/syntax/syntaxElement.ts @@ -8,7 +8,7 @@ module TypeScript { // nodes don't have positions or parents. export function isShared(element: ISyntaxElement): boolean { var kind = element.kind(); - return (kind === SyntaxKind.List || kind === SyntaxKind.SeparatedList) && (element).length === 0; + return kind === SyntaxKind.List && (element).length === 0; } export function syntaxTree(element: ISyntaxElement): SyntaxTree { @@ -225,10 +225,6 @@ module TypeScript { return element && element.kind() === SyntaxKind.List; } - export function isSeparatedList(element: ISyntaxElement): boolean { - return element && element.kind() === SyntaxKind.SeparatedList; - } - export function syntaxID(element: ISyntaxElement): number { if (isShared(element)) { throw Errors.invalidOperation("Should not use shared syntax element as a key."); @@ -350,7 +346,7 @@ module TypeScript { } function data(element: ISyntaxElement): number { - Debug.assert(isNode(element) || isList(element) || isSeparatedList(element)); + Debug.assert(isNode(element) || isList(element)); // Lists and nodes all have a 'data' element. var dataElement = <{ data: number }>element; diff --git a/src/services/syntax/syntaxGenerator.ts b/src/services/syntax/syntaxGenerator.ts index 9bf7256c42fd6..8b9008dcdfc41 100644 --- a/src/services/syntax/syntaxGenerator.ts +++ b/src/services/syntax/syntaxGenerator.ts @@ -1028,7 +1028,7 @@ function getType(child: IMemberDefinition): string { return "ISyntaxToken"; } else if (child.isSeparatedList) { - return child.elementType + "[]"; + return "ISeparatedSyntaxList<" + child.elementType + ">"; } else if (child.isList) { return child.elementType + "[]"; @@ -2180,12 +2180,12 @@ function generateRewriter(): string { " return isToken(node) ? this.visitToken(node) : this.visitNode(node);\r\n" + " }\r\n" + "\r\n" + -" public visitList(list: T[]): T[] {\r\n" + -" var newItems: T[] = undefined;\r\n" + +" public visitList(list: T): T {\r\n" + +" var newItems: T = undefined;\r\n" + "\r\n" + " for (var i = 0, n = list.length; i < n; i++) {\r\n" + " var item = list[i];\r\n" + -" var newItem = this.visitNodeOrToken(item);\r\n" + +" var newItem = this.visitNodeOrToken(item);\r\n" + "\r\n" + " if (item !== newItem && !newItems) {\r\n" + " newItems = [];\r\n" + @@ -2200,31 +2200,9 @@ function generateRewriter(): string { " }\r\n" + "\r\n" + " // Debug.assert(!newItems || newItems.length === childCount(list));\r\n" + -" return !newItems ? list : Syntax.list(newItems);\r\n" + +" return !newItems ? list : Syntax.list(newItems);\r\n" + " }\r\n" + -"\r\n" + -" public visitSeparatedList(list: T[]): T[] {\r\n" + -" var newItems: ISyntaxNodeOrToken[] = undefined;\r\n" + -"\r\n" + -" for (var i = 0, n = childCount(list); i < n; i++) {\r\n" + -" var item = childAt(list, i);\r\n" + -" var newItem = isToken(item) ? this.visitToken(item) : this.visitNode(item);\r\n" + -"\r\n" + -" if (item !== newItem && !newItems) {\r\n" + -" newItems = [];\r\n" + -" for (var j = 0; j < i; j++) {\r\n" + -" newItems.push(childAt(list, j));\r\n" + -" }\r\n" + -" }\r\n" + -"\r\n" + -" if (newItems) {\r\n" + -" newItems.push(newItem);\r\n" + -" }\r\n" + -" }\r\n" + -"\r\n" + -" // Debug.assert(newItems === undefined || newItems.length === childCount(list));\r\n" + -" return !newItems ? list : Syntax.separatedList(newItems);\r\n" + -" }\r\n"; +"\r\n" for (var i = 0; i < definitions.length; i++) { var definition = definitions[i]; @@ -2256,12 +2234,9 @@ function generateRewriter(): string { if (child.isToken) { result += "this.visitToken(node." + child.name + ")"; } - else if (child.isList) { + else if (child.isList || child.isSeparatedList) { result += "this.visitList(node." + child.name + ")"; } - else if (child.isSeparatedList) { - result += "this.visitSeparatedList(node." + child.name + ")"; - } else if (child.type === "SyntaxKind") { result += "node.kind"; } @@ -2318,17 +2293,7 @@ function generateWalker(): string { " list[i].accept(this);\r\n" + " }\r\n" + " }\r\n" + -"\r\n" + -" public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {\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"; +"\r\n"; for (var i = 0; i < definitions.length; i++) { var definition = definitions[i]; @@ -2347,12 +2312,9 @@ function generateWalker(): string { result += " this.visitToken(node." + child.name + ");\r\n"; } } - else if (child.isList) { + else if (child.isList || child.isSeparatedList) { result += " this.visitList(node." + child.name + ");\r\n"; } - else if (child.isSeparatedList) { - result += " this.visitSeparatedList(node." + child.name + ");\r\n"; - } else if (isNodeOrToken(child)) { if (child.isOptional) { result += " visitNodeOrToken(this, node." + child.name + ");\r\n"; @@ -2721,15 +2683,6 @@ function generateIsTypeScriptSpecific(): string { result += "module TypeScript {\r\n"; - result += " function isSeparatedListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\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"; - result += " return false;\r\n"; - result += " }\r\n\r\n"; - result += " function isListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\r\n" result += " for (var i = 0, n = list.length; i < n; i++) {\r\n"; result += " if (isTypeScriptSpecific(list[i])) {\r\n"; @@ -2743,7 +2696,6 @@ function generateIsTypeScriptSpecific(): string { result += " if (!element) { return false; }\r\n"; result += " if (isToken(element)) { return false; }\r\n"; result += " if (isList(element)) { return isListTypeScriptSpecific(element); }\r\n"; - result += " if (isSeparatedList(element)) { return isSeparatedListTypeScriptSpecific(element); }\r\n\r\n"; result += " switch (element.kind()) {\r\n"; for (var i = 0; i < definitions.length; i++) { @@ -2850,12 +2802,9 @@ function generateIsTypeScriptSpecificMethod(definition: ITypeDefinition): string addedCheck = true; if (child.isTypeScriptSpecific) { - if (child.isList) { + if (child.isList || child.isSeparatedList) { result += getPropertyAccess(child, "node") + ".length > 0"; } - else if (child.isSeparatedList) { - result += getPropertyAccess(child, "node") + ".childCount() > 0"; - } else { result += "!!" + getPropertyAccess(child, "node"); } diff --git a/src/services/syntax/syntaxKind.ts b/src/services/syntax/syntaxKind.ts index 3f27168c678d6..a009a458dd5eb 100644 --- a/src/services/syntax/syntaxKind.ts +++ b/src/services/syntax/syntaxKind.ts @@ -5,8 +5,6 @@ module TypeScript { // Variable width tokens, trivia and lists. None, List, - SeparatedList, - TriviaList, // Trivia WhitespaceTrivia, diff --git a/src/services/syntax/syntaxList.ts b/src/services/syntax/syntaxList.ts index ba266be128ef2..1be7eb25ddf61 100644 --- a/src/services/syntax/syntaxList.ts +++ b/src/services/syntax/syntaxList.ts @@ -2,34 +2,27 @@ interface Array { data: number; - separators?: TypeScript.ISyntaxToken[]; - separatedListLength?: number; kind(): TypeScript.SyntaxKind; parent: TypeScript.ISyntaxElement; - separatorCount(): number; - separatorAt(index: number): TypeScript.ISyntaxToken; - childCount(): number; childAt(index: number): TypeScript.ISyntaxNodeOrToken; } module TypeScript { - export function separatedListChildAt(list: ISyntaxNodeOrToken[], index: number) { - return index % 2 === 0 ? list[index >> 1] : list.separators[index >> 1]; + export interface ISeparatedSyntaxList extends Array { + separatorCount(): number; + separatorAt(index: number): TypeScript.ISyntaxToken; + + nonSeparatorCount(): number; + nonSeparatorAt(index: number): T; } } module TypeScript.Syntax { var _emptyList: ISyntaxNodeOrToken[] = []; - var _emptySeparatedList: ISyntaxNodeOrToken[] = []; - var _emptySeparators: ISyntaxToken[] = []; - - _emptySeparatedList.separators = _emptySeparators; - _emptySeparatedList.separatedListLength = 0; - function assertEmptyLists() { // Debug.assert(_emptyList.length === 0); // var separators = _emptySeparatedList.separators; @@ -46,41 +39,49 @@ module TypeScript.Syntax { } addArrayFunction("kind", function () { - return this.separators === undefined ? SyntaxKind.List : SyntaxKind.SeparatedList; + return SyntaxKind.List; }); addArrayFunction("childCount", function (): number { - return this.separators ? this.separatedListLength : this.length; + return this.length; }); addArrayFunction("childAt", function (index: number): ISyntaxNodeOrToken { - if (this.separators) { - return index % 2 === 0 ? this[index >> 1] : this.separators[index >> 1]; - } - else { - return this[index]; - } + return this[index]; }); addArrayFunction("separatorCount", function (): number { assertEmptyLists(); // Debug.assert(this.kind === SyntaxKind.SeparatedList); - return this.separators.length; + return this.length >> 1; + }); + + addArrayFunction("nonSeparatorCount", function (): number { + assertEmptyLists(); + // Debug.assert(this.kind === SyntaxKind.SeparatedList); + return (this.length + 1) >> 1; }); addArrayFunction("separatorAt", function (index: number): ISyntaxToken { assertEmptyLists(); // Debug.assert(this.kind === SyntaxKind.SeparatedList); // Debug.assert(index >= 0 && index < this.separators.length); - return this.separators[index]; + return this[(index << 1) + 1]; + }); + + addArrayFunction("nonSeparatorAt", function (index: number): ISyntaxToken { + assertEmptyLists(); + // Debug.assert(this.kind === SyntaxKind.SeparatedList); + // Debug.assert(index >= 0 && index < this.separators.length); + return this[index << 1]; }); export function emptyList(): T[] { - return _emptyList; + return _emptyList; } - export function emptySeparatedList(): T[] { - return _emptySeparatedList; + export function emptySeparatedList(): ISeparatedSyntaxList { + return >_emptyList; } export function list(nodes: T[]): T[] { @@ -95,25 +96,18 @@ module TypeScript.Syntax { return nodes; } - export function separatedList(nodes: T[], separators: ISyntaxToken[]): T[] { - if (!nodes || nodes.length === 0) { - return emptySeparatedList(); + export function separatedList(nodesAndTokens: ISyntaxNodeOrToken[]): ISeparatedSyntaxList { + if (!nodesAndTokens || nodesAndTokens.length === 0) { + return >emptyList(); } // Debug.assert(separators.length === nodes.length || separators.length == (nodes.length - 1)); - for (var i = 0, n = nodes.length; i < n; i++) { - nodes[i].parent = nodes; - } - - for (var i = 0, n = separators.length; i < n; i++) { - separators[i].parent = nodes; + for (var i = 0, n = nodesAndTokens.length; i < n; i++) { + nodesAndTokens[i].parent = nodesAndTokens; } - nodes.separators = separators.length === 0 ? _emptySeparators : separators; - nodes.separatedListLength = nodes.length + separators.length; - - return nodes; + return >nodesAndTokens; } export function nonSeparatorIndexOf(list: T[], ast: ISyntaxNodeOrToken): number { diff --git a/src/services/syntax/syntaxNodes.concrete.generated.ts b/src/services/syntax/syntaxNodes.concrete.generated.ts index ea5ded9990809..6031360a1484f 100644 --- a/src/services/syntax/syntaxNodes.concrete.generated.ts +++ b/src/services/syntax/syntaxNodes.concrete.generated.ts @@ -76,10 +76,10 @@ module TypeScript.Syntax.Concrete { } export class ObjectTypeSyntax extends SyntaxNode implements ITypeSyntax { public openBraceToken: ISyntaxToken; - public typeMembers: ITypeMemberSyntax[]; + public typeMembers: ISeparatedSyntaxList; public closeBraceToken: ISyntaxToken; public _typeBrand: any; - constructor(data: number, openBraceToken: ISyntaxToken, typeMembers: ITypeMemberSyntax[], closeBraceToken: ISyntaxToken) { + constructor(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { super(data); this.openBraceToken = openBraceToken, this.typeMembers = typeMembers, @@ -296,10 +296,10 @@ module TypeScript.Syntax.Concrete { } export class TupleTypeSyntax extends SyntaxNode implements ITypeSyntax { public openBracketToken: ISyntaxToken; - public types: ITypeSyntax[]; + public types: ISeparatedSyntaxList; public closeBracketToken: ISyntaxToken; public _typeBrand: any; - constructor(data: number, openBracketToken: ISyntaxToken, types: ITypeSyntax[], closeBracketToken: ISyntaxToken) { + constructor(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken) { super(data); this.openBracketToken = openBracketToken, this.types = types, @@ -611,10 +611,10 @@ module TypeScript.Syntax.Concrete { public enumKeyword: ISyntaxToken; public identifier: ISyntaxToken; public openBraceToken: ISyntaxToken; - public enumElements: EnumElementSyntax[]; + public enumElements: ISeparatedSyntaxList; public closeBraceToken: ISyntaxToken; public _moduleElementBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: EnumElementSyntax[], closeBraceToken: ISyntaxToken) { + constructor(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { super(data); this.modifiers = modifiers, this.enumKeyword = enumKeyword, @@ -1096,11 +1096,11 @@ module TypeScript.Syntax.Concrete { } export class IndexSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax { public openBracketToken: ISyntaxToken; - public parameters: ParameterSyntax[]; + public parameters: ISeparatedSyntaxList; public closeBracketToken: ISyntaxToken; public typeAnnotation: TypeAnnotationSyntax; public _typeMemberBrand: any; - constructor(data: number, openBracketToken: ISyntaxToken, parameters: ParameterSyntax[], closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) { + constructor(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) { super(data); this.openBracketToken = openBracketToken, this.parameters = parameters, @@ -2224,10 +2224,10 @@ module TypeScript.Syntax.Concrete { } export class ArrayLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax { public openBracketToken: ISyntaxToken; - public expressions: IExpressionSyntax[]; + public expressions: ISeparatedSyntaxList; 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) { + constructor(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken) { super(data); this.openBracketToken = openBracketToken, this.expressions = expressions, @@ -2260,10 +2260,10 @@ module TypeScript.Syntax.Concrete { } export class ObjectLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax { public openBraceToken: ISyntaxToken; - public propertyAssignments: IPropertyAssignmentSyntax[]; + public propertyAssignments: ISeparatedSyntaxList; 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) { + constructor(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { super(data); this.openBraceToken = openBraceToken, this.propertyAssignments = propertyAssignments, @@ -2590,8 +2590,8 @@ module TypeScript.Syntax.Concrete { } export class VariableDeclarationSyntax extends SyntaxNode { public varKeyword: ISyntaxToken; - public variableDeclarators: VariableDeclaratorSyntax[]; - constructor(data: number, varKeyword: ISyntaxToken, variableDeclarators: VariableDeclaratorSyntax[]) { + public variableDeclarators: ISeparatedSyntaxList; + constructor(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList) { super(data); this.varKeyword = varKeyword, this.variableDeclarators = variableDeclarators, @@ -2657,9 +2657,9 @@ module TypeScript.Syntax.Concrete { export class ArgumentListSyntax extends SyntaxNode { public typeArgumentList: TypeArgumentListSyntax; public openParenToken: ISyntaxToken; - public arguments: IExpressionSyntax[]; + public arguments: ISeparatedSyntaxList; public closeParenToken: ISyntaxToken; - constructor(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: IExpressionSyntax[], closeParenToken: ISyntaxToken) { + constructor(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: ISeparatedSyntaxList, closeParenToken: ISyntaxToken) { super(data); this.typeArgumentList = typeArgumentList, this.openParenToken = openParenToken, @@ -2695,9 +2695,9 @@ module TypeScript.Syntax.Concrete { } export class ParameterListSyntax extends SyntaxNode { public openParenToken: ISyntaxToken; - public parameters: ParameterSyntax[]; + public parameters: ISeparatedSyntaxList; public closeParenToken: ISyntaxToken; - constructor(data: number, openParenToken: ISyntaxToken, parameters: ParameterSyntax[], closeParenToken: ISyntaxToken) { + constructor(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeParenToken: ISyntaxToken) { super(data); this.openParenToken = openParenToken, this.parameters = parameters, @@ -2730,9 +2730,9 @@ module TypeScript.Syntax.Concrete { } export class TypeArgumentListSyntax extends SyntaxNode { public lessThanToken: ISyntaxToken; - public typeArguments: ITypeSyntax[]; + public typeArguments: ISeparatedSyntaxList; public greaterThanToken: ISyntaxToken; - constructor(data: number, lessThanToken: ISyntaxToken, typeArguments: ITypeSyntax[], greaterThanToken: ISyntaxToken) { + constructor(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken) { super(data); this.lessThanToken = lessThanToken, this.typeArguments = typeArguments, @@ -2765,9 +2765,9 @@ module TypeScript.Syntax.Concrete { } export class TypeParameterListSyntax extends SyntaxNode { public lessThanToken: ISyntaxToken; - public typeParameters: TypeParameterSyntax[]; + public typeParameters: ISeparatedSyntaxList; public greaterThanToken: ISyntaxToken; - constructor(data: number, lessThanToken: ISyntaxToken, typeParameters: TypeParameterSyntax[], greaterThanToken: ISyntaxToken) { + constructor(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken) { super(data); this.lessThanToken = lessThanToken, this.typeParameters = typeParameters, @@ -2800,8 +2800,8 @@ module TypeScript.Syntax.Concrete { } export class HeritageClauseSyntax extends SyntaxNode { public extendsOrImplementsKeyword: ISyntaxToken; - public typeNames: INameSyntax[]; - constructor(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: INameSyntax[]) { + public typeNames: ISeparatedSyntaxList; + constructor(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList) { super(data); this.extendsOrImplementsKeyword = extendsOrImplementsKeyword, this.typeNames = typeNames, diff --git a/src/services/syntax/syntaxNodes.interfaces.generated.ts b/src/services/syntax/syntaxNodes.interfaces.generated.ts index dd3841719fd0d..37538e0c6c417 100644 --- a/src/services/syntax/syntaxNodes.interfaces.generated.ts +++ b/src/services/syntax/syntaxNodes.interfaces.generated.ts @@ -13,7 +13,7 @@ module TypeScript { } export interface ObjectTypeSyntax extends ISyntaxNode, ITypeSyntax { openBraceToken: ISyntaxToken; - typeMembers: ITypeMemberSyntax[]; + typeMembers: ISeparatedSyntaxList; closeBraceToken: ISyntaxToken; } export interface FunctionTypeSyntax extends ISyntaxNode, ITypeSyntax { @@ -44,7 +44,7 @@ module TypeScript { } export interface TupleTypeSyntax extends ISyntaxNode, ITypeSyntax { openBracketToken: ISyntaxToken; - types: ITypeSyntax[]; + types: ISeparatedSyntaxList; closeBracketToken: ISyntaxToken; } export interface UnionTypeSyntax extends ISyntaxNode, ITypeSyntax { @@ -97,7 +97,7 @@ module TypeScript { enumKeyword: ISyntaxToken; identifier: ISyntaxToken; openBraceToken: ISyntaxToken; - enumElements: EnumElementSyntax[]; + enumElements: ISeparatedSyntaxList; closeBraceToken: ISyntaxToken; } export interface ImportDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax { @@ -168,7 +168,7 @@ module TypeScript { } export interface IndexSignatureSyntax extends ISyntaxNode, ITypeMemberSyntax { openBracketToken: ISyntaxToken; - parameters: ParameterSyntax[]; + parameters: ISeparatedSyntaxList; closeBracketToken: ISyntaxToken; typeAnnotation: TypeAnnotationSyntax; } @@ -334,12 +334,12 @@ module TypeScript { } export interface ArrayLiteralExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { openBracketToken: ISyntaxToken; - expressions: IExpressionSyntax[]; + expressions: ISeparatedSyntaxList; closeBracketToken: ISyntaxToken; } export interface ObjectLiteralExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { openBraceToken: ISyntaxToken; - propertyAssignments: IPropertyAssignmentSyntax[]; + propertyAssignments: ISeparatedSyntaxList; closeBraceToken: ISyntaxToken; } export interface ObjectCreationExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { @@ -386,7 +386,7 @@ module TypeScript { } export interface VariableDeclarationSyntax extends ISyntaxNode { varKeyword: ISyntaxToken; - variableDeclarators: VariableDeclaratorSyntax[]; + variableDeclarators: ISeparatedSyntaxList; } export interface VariableDeclaratorSyntax extends ISyntaxNode { propertyName: ISyntaxToken; @@ -396,27 +396,27 @@ module TypeScript { export interface ArgumentListSyntax extends ISyntaxNode { typeArgumentList: TypeArgumentListSyntax; openParenToken: ISyntaxToken; - arguments: IExpressionSyntax[]; + arguments: ISeparatedSyntaxList; closeParenToken: ISyntaxToken; } export interface ParameterListSyntax extends ISyntaxNode { openParenToken: ISyntaxToken; - parameters: ParameterSyntax[]; + parameters: ISeparatedSyntaxList; closeParenToken: ISyntaxToken; } export interface TypeArgumentListSyntax extends ISyntaxNode { lessThanToken: ISyntaxToken; - typeArguments: ITypeSyntax[]; + typeArguments: ISeparatedSyntaxList; greaterThanToken: ISyntaxToken; } export interface TypeParameterListSyntax extends ISyntaxNode { lessThanToken: ISyntaxToken; - typeParameters: TypeParameterSyntax[]; + typeParameters: ISeparatedSyntaxList; greaterThanToken: ISyntaxToken; } export interface HeritageClauseSyntax extends ISyntaxNode { extendsOrImplementsKeyword: ISyntaxToken; - typeNames: INameSyntax[]; + typeNames: ISeparatedSyntaxList; } export interface EqualsValueClauseSyntax extends ISyntaxNode { equalsToken: ISyntaxToken; @@ -498,20 +498,20 @@ module TypeScript { isConcrete: boolean; SourceUnitSyntax: { new(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken): SourceUnitSyntax }; QualifiedNameSyntax: { new(data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken): QualifiedNameSyntax }; - ObjectTypeSyntax: { new(data: number, openBraceToken: ISyntaxToken, typeMembers: ITypeMemberSyntax[], closeBraceToken: ISyntaxToken): ObjectTypeSyntax }; + ObjectTypeSyntax: { new(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken): ObjectTypeSyntax }; FunctionTypeSyntax: { new(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): FunctionTypeSyntax }; ArrayTypeSyntax: { new(data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken): ArrayTypeSyntax }; ConstructorTypeSyntax: { new(data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): ConstructorTypeSyntax }; GenericTypeSyntax: { new(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax): GenericTypeSyntax }; TypeQuerySyntax: { new(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax): TypeQuerySyntax }; - TupleTypeSyntax: { new(data: number, openBracketToken: ISyntaxToken, types: ITypeSyntax[], closeBracketToken: ISyntaxToken): TupleTypeSyntax }; + TupleTypeSyntax: { new(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken): TupleTypeSyntax }; UnionTypeSyntax: { new(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax): UnionTypeSyntax }; ParenthesizedTypeSyntax: { new(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken): ParenthesizedTypeSyntax }; InterfaceDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax): InterfaceDeclarationSyntax }; FunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): FunctionDeclarationSyntax }; ModuleDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken): ModuleDeclarationSyntax }; ClassDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken): ClassDeclarationSyntax }; - EnumDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: EnumElementSyntax[], closeBraceToken: ISyntaxToken): EnumDeclarationSyntax }; + EnumDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken): EnumDeclarationSyntax }; ImportDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken): ImportDeclarationSyntax }; ExportAssignmentSyntax: { new(data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): ExportAssignmentSyntax }; MemberFunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): MemberFunctionDeclarationSyntax }; @@ -523,7 +523,7 @@ module TypeScript { PropertySignatureSyntax: { new(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): PropertySignatureSyntax }; CallSignatureSyntax: { new(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax): CallSignatureSyntax }; ConstructSignatureSyntax: { new(data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax): ConstructSignatureSyntax }; - IndexSignatureSyntax: { new(data: number, openBracketToken: ISyntaxToken, parameters: ParameterSyntax[], closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): IndexSignatureSyntax }; + IndexSignatureSyntax: { new(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): IndexSignatureSyntax }; MethodSignatureSyntax: { new(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax): MethodSignatureSyntax }; BlockSyntax: { new(data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken): BlockSyntax }; IfStatementSyntax: { new(data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax): IfStatementSyntax }; @@ -552,8 +552,8 @@ module TypeScript { PostfixUnaryExpressionSyntax: { new(data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken): PostfixUnaryExpressionSyntax }; MemberAccessExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken): MemberAccessExpressionSyntax }; InvocationExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax): InvocationExpressionSyntax }; - ArrayLiteralExpressionSyntax: { new(data: number, openBracketToken: ISyntaxToken, expressions: IExpressionSyntax[], closeBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax }; - ObjectLiteralExpressionSyntax: { new(data: number, openBraceToken: ISyntaxToken, propertyAssignments: IPropertyAssignmentSyntax[], closeBraceToken: ISyntaxToken): ObjectLiteralExpressionSyntax }; + ArrayLiteralExpressionSyntax: { new(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax }; + ObjectLiteralExpressionSyntax: { new(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken): ObjectLiteralExpressionSyntax }; ObjectCreationExpressionSyntax: { new(data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax): ObjectCreationExpressionSyntax }; ParenthesizedExpressionSyntax: { new(data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken): ParenthesizedExpressionSyntax }; ParenthesizedArrowFunctionExpressionSyntax: { new(data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax): ParenthesizedArrowFunctionExpressionSyntax }; @@ -562,13 +562,13 @@ module TypeScript { ElementAccessExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken): ElementAccessExpressionSyntax }; FunctionExpressionSyntax: { new(data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): FunctionExpressionSyntax }; OmittedExpressionSyntax: { new(data: number): OmittedExpressionSyntax }; - VariableDeclarationSyntax: { new(data: number, varKeyword: ISyntaxToken, variableDeclarators: VariableDeclaratorSyntax[]): VariableDeclarationSyntax }; + VariableDeclarationSyntax: { new(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList): VariableDeclarationSyntax }; VariableDeclaratorSyntax: { new(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax): VariableDeclaratorSyntax }; - ArgumentListSyntax: { new(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, arguments: IExpressionSyntax[], closeParenToken: ISyntaxToken): ArgumentListSyntax }; - ParameterListSyntax: { new(data: number, openParenToken: ISyntaxToken, parameters: ParameterSyntax[], closeParenToken: ISyntaxToken): ParameterListSyntax }; - TypeArgumentListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeArguments: ITypeSyntax[], greaterThanToken: ISyntaxToken): TypeArgumentListSyntax }; - TypeParameterListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeParameters: TypeParameterSyntax[], greaterThanToken: ISyntaxToken): TypeParameterListSyntax }; - HeritageClauseSyntax: { new(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: INameSyntax[]): HeritageClauseSyntax }; + ArgumentListSyntax: { new(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, arguments: ISeparatedSyntaxList, closeParenToken: ISyntaxToken): ArgumentListSyntax }; + ParameterListSyntax: { new(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeParenToken: ISyntaxToken): ParameterListSyntax }; + TypeArgumentListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken): TypeArgumentListSyntax }; + TypeParameterListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken): TypeParameterListSyntax }; + HeritageClauseSyntax: { new(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList): HeritageClauseSyntax }; EqualsValueClauseSyntax: { new(data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax): EqualsValueClauseSyntax }; CaseSwitchClauseSyntax: { new(data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]): CaseSwitchClauseSyntax }; DefaultSwitchClauseSyntax: { new(data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]): DefaultSwitchClauseSyntax }; diff --git a/src/services/syntax/syntaxTree.ts b/src/services/syntax/syntaxTree.ts index 5d2584f6b6105..a568e2313be4d 100644 --- a/src/services/syntax/syntaxTree.ts +++ b/src/services/syntax/syntaxTree.ts @@ -169,10 +169,10 @@ module TypeScript { private checkParameterListOrder(node: ParameterListSyntax): boolean { var seenOptionalParameter = false; - var parameterCount = node.parameters.length; + var parameterCount = node.parameters.nonSeparatorCount(); for (var i = 0; i < parameterCount; i++) { - var parameter = node.parameters[i]; + var parameter = node.parameters.nonSeparatorAt(i); if (parameter.dotDotDotToken) { if (i !== (parameterCount - 1)) { @@ -210,8 +210,8 @@ module TypeScript { } private checkParameterListAcessibilityModifiers(node: ParameterListSyntax): boolean { - for (var i = 0, n = node.parameters.length; i < n; i++) { - var parameter = node.parameters[i]; + for (var i = 0, n = node.parameters.nonSeparatorCount(); i < n; i++) { + var parameter = node.parameters.nonSeparatorAt(i); if (this.checkParameterAccessibilityModifiers(node, parameter)) { return true; @@ -344,7 +344,7 @@ module TypeScript { return true; } - var parameter = node.parameters[0]; + var parameter = node.parameters.nonSeparatorAt(0); if (parameter.dotDotDotToken) { this.pushDiagnostic(parameter, DiagnosticCode.Index_signatures_cannot_have_rest_parameters); @@ -407,7 +407,7 @@ module TypeScript { return true; } - if (heritageClause.typeNames.length > 1) { + if (heritageClause.typeNames.nonSeparatorCount() > 1) { this.pushDiagnostic(heritageClause, DiagnosticCode.Classes_can_only_extend_a_single_class); return true; } @@ -654,12 +654,12 @@ module TypeScript { private checkSetAccessorParameter(node: SetAccessorSyntax): boolean { var parameters = node.callSignature.parameterList.parameters; - if (parameters.childCount() !== 1) { + if (parameters.nonSeparatorCount() !== 1) { this.pushDiagnostic(node.propertyName, DiagnosticCode.set_accessor_must_have_exactly_one_parameter); return true; } - var parameter = parameters[0]; + var parameter = parameters.nonSeparatorAt(0); if (parameter.questionToken) { this.pushDiagnostic(parameter, DiagnosticCode.set_accessor_parameter_cannot_be_optional); diff --git a/src/services/syntax/syntaxTriviaList.ts b/src/services/syntax/syntaxTriviaList.ts index ad0b2b51fa409..ad5f1df3039d9 100644 --- a/src/services/syntax/syntaxTriviaList.ts +++ b/src/services/syntax/syntaxTriviaList.ts @@ -28,10 +28,6 @@ module TypeScript { module TypeScript.Syntax { class EmptyTriviaList implements ISyntaxTriviaList { - public kind() { - return SyntaxKind.TriviaList; - } - public isShared(): boolean { return true; } @@ -91,10 +87,6 @@ module TypeScript.Syntax { this.item.parent = this; } - public kind() { - return SyntaxKind.TriviaList; - } - public isShared(): boolean { return false; } @@ -155,10 +147,6 @@ module TypeScript.Syntax { }); } - public kind() { - return SyntaxKind.TriviaList; - } - public isShared(): boolean { return false; } diff --git a/src/services/syntax/syntaxWalker.generated.ts b/src/services/syntax/syntaxWalker.generated.ts index b1ba8d5382191..4122d8ce50990 100644 --- a/src/services/syntax/syntaxWalker.generated.ts +++ b/src/services/syntax/syntaxWalker.generated.ts @@ -27,16 +27,6 @@ module TypeScript { } } - public visitSeparatedList(list: ISyntaxNodeOrToken[]): void { - for (var i = 0, n = list.separatedListLength; i < n; i++) { - if (i % 2 === 0) { - list[i >> 1].accept(this); - } - else { - this.visitToken(list.separators[i >> 1]); - } - } - } public visitSourceUnit(node: SourceUnitSyntax): void { this.visitList(node.moduleElements); @@ -51,7 +41,7 @@ module TypeScript { public visitObjectType(node: ObjectTypeSyntax): void { this.visitToken(node.openBraceToken); - this.visitSeparatedList(node.typeMembers); + this.visitList(node.typeMembers); this.visitToken(node.closeBraceToken); } @@ -88,7 +78,7 @@ module TypeScript { public visitTupleType(node: TupleTypeSyntax): void { this.visitToken(node.openBracketToken); - this.visitSeparatedList(node.types); + this.visitList(node.types); this.visitToken(node.closeBracketToken); } @@ -148,7 +138,7 @@ module TypeScript { this.visitToken(node.enumKeyword); this.visitToken(node.identifier); this.visitToken(node.openBraceToken); - this.visitSeparatedList(node.enumElements); + this.visitList(node.enumElements); this.visitToken(node.closeBraceToken); } @@ -231,7 +221,7 @@ module TypeScript { public visitIndexSignature(node: IndexSignatureSyntax): void { this.visitToken(node.openBracketToken); - this.visitSeparatedList(node.parameters); + this.visitList(node.parameters); this.visitToken(node.closeBracketToken); this.visitOptionalNode(node.typeAnnotation); } @@ -426,13 +416,13 @@ module TypeScript { public visitArrayLiteralExpression(node: ArrayLiteralExpressionSyntax): void { this.visitToken(node.openBracketToken); - this.visitSeparatedList(node.expressions); + this.visitList(node.expressions); this.visitToken(node.closeBracketToken); } public visitObjectLiteralExpression(node: ObjectLiteralExpressionSyntax): void { this.visitToken(node.openBraceToken); - this.visitSeparatedList(node.propertyAssignments); + this.visitList(node.propertyAssignments); this.visitToken(node.closeBraceToken); } @@ -488,7 +478,7 @@ module TypeScript { public visitVariableDeclaration(node: VariableDeclarationSyntax): void { this.visitToken(node.varKeyword); - this.visitSeparatedList(node.variableDeclarators); + this.visitList(node.variableDeclarators); } public visitVariableDeclarator(node: VariableDeclaratorSyntax): void { @@ -500,31 +490,31 @@ module TypeScript { public visitArgumentList(node: ArgumentListSyntax): void { this.visitOptionalNode(node.typeArgumentList); this.visitToken(node.openParenToken); - this.visitSeparatedList(node.arguments); + this.visitList(node.arguments); this.visitToken(node.closeParenToken); } public visitParameterList(node: ParameterListSyntax): void { this.visitToken(node.openParenToken); - this.visitSeparatedList(node.parameters); + this.visitList(node.parameters); this.visitToken(node.closeParenToken); } public visitTypeArgumentList(node: TypeArgumentListSyntax): void { this.visitToken(node.lessThanToken); - this.visitSeparatedList(node.typeArguments); + this.visitList(node.typeArguments); this.visitToken(node.greaterThanToken); } public visitTypeParameterList(node: TypeParameterListSyntax): void { this.visitToken(node.lessThanToken); - this.visitSeparatedList(node.typeParameters); + this.visitList(node.typeParameters); this.visitToken(node.greaterThanToken); } public visitHeritageClause(node: HeritageClauseSyntax): void { this.visitToken(node.extendsOrImplementsKeyword); - this.visitSeparatedList(node.typeNames); + this.visitList(node.typeNames); } public visitEqualsValueClause(node: EqualsValueClauseSyntax): void { diff --git a/src/services/syntax/testUtilities.ts b/src/services/syntax/testUtilities.ts index 18853a6446471..113c8043699b3 100644 --- a/src/services/syntax/testUtilities.ts +++ b/src/services/syntax/testUtilities.ts @@ -126,31 +126,6 @@ module TypeScript { return true; } - function separatedListStructuralEquals(list1: T[], list2: T[], checkParents: boolean, text1: ISimpleText, text2: ISimpleText): boolean { - Debug.assert(TypeScript.isShared(list1) || list1.parent); - Debug.assert(TypeScript.isShared(list2) || list2.parent); - - if (list1.childCount() !== list2.childCount()) { - return false; - } - - 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); - assertParent(list2, element2); - } - - if (!nodeOrTokenStructuralEquals(element1, element2, checkParents, text1, text2)) { - return false; - } - } - - return true; - } - export function elementStructuralEquals(element1: TypeScript.ISyntaxElement, element2: TypeScript.ISyntaxElement, checkParents: boolean, text1: ISimpleText, text2: ISimpleText) { if (element1 === element2) { return true; @@ -192,9 +167,6 @@ module TypeScript { else if (TypeScript.isList(element1)) { return listStructuralEquals(element1, element2, checkParents, text1, text2); } - else if (TypeScript.isSeparatedList(element1)) { - return separatedListStructuralEquals(element1, element2, checkParents, text1, text2); - } throw TypeScript.Errors.invalidOperation(); }