From 259ca15b30ddb39ac907d27c26147f0b1ba77b46 Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Tue, 5 May 2015 14:56:02 -0700 Subject: [PATCH 1/3] Sync tsserver.js and lib.d.ts version --- tsserver/lib.d.ts | 1 + tsserver/lib.es6.d.ts | 1 + tsserver/tsserver.js | 18908 +++++++++++++--------------------------- 3 files changed, 6252 insertions(+), 12658 deletions(-) diff --git a/tsserver/lib.d.ts b/tsserver/lib.d.ts index 944b10ac..e583f1ac 100644 --- a/tsserver/lib.d.ts +++ b/tsserver/lib.d.ts @@ -15838,6 +15838,7 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget { overrideMimeType(mime: string): void; send(data?: Document): void; send(data?: string): void; + send(data?: any): void; setRequestHeader(header: string, value: string): void; DONE: number; HEADERS_RECEIVED: number; diff --git a/tsserver/lib.es6.d.ts b/tsserver/lib.es6.d.ts index 8266e426..f839a3e3 100644 --- a/tsserver/lib.es6.d.ts +++ b/tsserver/lib.es6.d.ts @@ -17217,6 +17217,7 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget { overrideMimeType(mime: string): void; send(data?: Document): void; send(data?: string): void; + send(data?: any): void; setRequestHeader(header: string, value: string): void; DONE: number; HEADERS_RECEIVED: number; diff --git a/tsserver/tsserver.js b/tsserver/tsserver.js index bb8ec74e..e492912a 100644 --- a/tsserver/tsserver.js +++ b/tsserver/tsserver.js @@ -1,697 +1,36 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + var ts; (function (ts) { - // token > SyntaxKind.Identifer => token is a keyword - (function (SyntaxKind) { - SyntaxKind[SyntaxKind["Unknown"] = 0] = "Unknown"; - SyntaxKind[SyntaxKind["EndOfFileToken"] = 1] = "EndOfFileToken"; - SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 2] = "SingleLineCommentTrivia"; - SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 3] = "MultiLineCommentTrivia"; - SyntaxKind[SyntaxKind["NewLineTrivia"] = 4] = "NewLineTrivia"; - SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 5] = "WhitespaceTrivia"; - // We detect and provide better error recovery when we encounter a git merge marker. This - // allows us to edit files with git-conflict markers in them in a much more pleasant manner. - SyntaxKind[SyntaxKind["ConflictMarkerTrivia"] = 6] = "ConflictMarkerTrivia"; - // Literals - SyntaxKind[SyntaxKind["NumericLiteral"] = 7] = "NumericLiteral"; - SyntaxKind[SyntaxKind["StringLiteral"] = 8] = "StringLiteral"; - SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 9] = "RegularExpressionLiteral"; - SyntaxKind[SyntaxKind["NoSubstitutionTemplateLiteral"] = 10] = "NoSubstitutionTemplateLiteral"; - // Pseudo-literals - SyntaxKind[SyntaxKind["TemplateHead"] = 11] = "TemplateHead"; - SyntaxKind[SyntaxKind["TemplateMiddle"] = 12] = "TemplateMiddle"; - SyntaxKind[SyntaxKind["TemplateTail"] = 13] = "TemplateTail"; - // Punctuation - SyntaxKind[SyntaxKind["OpenBraceToken"] = 14] = "OpenBraceToken"; - SyntaxKind[SyntaxKind["CloseBraceToken"] = 15] = "CloseBraceToken"; - SyntaxKind[SyntaxKind["OpenParenToken"] = 16] = "OpenParenToken"; - SyntaxKind[SyntaxKind["CloseParenToken"] = 17] = "CloseParenToken"; - SyntaxKind[SyntaxKind["OpenBracketToken"] = 18] = "OpenBracketToken"; - SyntaxKind[SyntaxKind["CloseBracketToken"] = 19] = "CloseBracketToken"; - SyntaxKind[SyntaxKind["DotToken"] = 20] = "DotToken"; - SyntaxKind[SyntaxKind["DotDotDotToken"] = 21] = "DotDotDotToken"; - SyntaxKind[SyntaxKind["SemicolonToken"] = 22] = "SemicolonToken"; - SyntaxKind[SyntaxKind["CommaToken"] = 23] = "CommaToken"; - SyntaxKind[SyntaxKind["LessThanToken"] = 24] = "LessThanToken"; - SyntaxKind[SyntaxKind["GreaterThanToken"] = 25] = "GreaterThanToken"; - SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 26] = "LessThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 27] = "GreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 28] = "EqualsEqualsToken"; - SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 29] = "ExclamationEqualsToken"; - SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 30] = "EqualsEqualsEqualsToken"; - SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 31] = "ExclamationEqualsEqualsToken"; - SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 32] = "EqualsGreaterThanToken"; - SyntaxKind[SyntaxKind["PlusToken"] = 33] = "PlusToken"; - SyntaxKind[SyntaxKind["MinusToken"] = 34] = "MinusToken"; - SyntaxKind[SyntaxKind["AsteriskToken"] = 35] = "AsteriskToken"; - SyntaxKind[SyntaxKind["SlashToken"] = 36] = "SlashToken"; - SyntaxKind[SyntaxKind["PercentToken"] = 37] = "PercentToken"; - SyntaxKind[SyntaxKind["PlusPlusToken"] = 38] = "PlusPlusToken"; - SyntaxKind[SyntaxKind["MinusMinusToken"] = 39] = "MinusMinusToken"; - SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 40] = "LessThanLessThanToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 41] = "GreaterThanGreaterThanToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 42] = "GreaterThanGreaterThanGreaterThanToken"; - SyntaxKind[SyntaxKind["AmpersandToken"] = 43] = "AmpersandToken"; - SyntaxKind[SyntaxKind["BarToken"] = 44] = "BarToken"; - SyntaxKind[SyntaxKind["CaretToken"] = 45] = "CaretToken"; - SyntaxKind[SyntaxKind["ExclamationToken"] = 46] = "ExclamationToken"; - SyntaxKind[SyntaxKind["TildeToken"] = 47] = "TildeToken"; - SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 48] = "AmpersandAmpersandToken"; - SyntaxKind[SyntaxKind["BarBarToken"] = 49] = "BarBarToken"; - SyntaxKind[SyntaxKind["QuestionToken"] = 50] = "QuestionToken"; - SyntaxKind[SyntaxKind["ColonToken"] = 51] = "ColonToken"; - SyntaxKind[SyntaxKind["AtToken"] = 52] = "AtToken"; - // Assignments - SyntaxKind[SyntaxKind["EqualsToken"] = 53] = "EqualsToken"; - SyntaxKind[SyntaxKind["PlusEqualsToken"] = 54] = "PlusEqualsToken"; - SyntaxKind[SyntaxKind["MinusEqualsToken"] = 55] = "MinusEqualsToken"; - SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 56] = "AsteriskEqualsToken"; - SyntaxKind[SyntaxKind["SlashEqualsToken"] = 57] = "SlashEqualsToken"; - SyntaxKind[SyntaxKind["PercentEqualsToken"] = 58] = "PercentEqualsToken"; - SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 59] = "LessThanLessThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 60] = "GreaterThanGreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 61] = "GreaterThanGreaterThanGreaterThanEqualsToken"; - SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 62] = "AmpersandEqualsToken"; - SyntaxKind[SyntaxKind["BarEqualsToken"] = 63] = "BarEqualsToken"; - SyntaxKind[SyntaxKind["CaretEqualsToken"] = 64] = "CaretEqualsToken"; - // Identifiers - SyntaxKind[SyntaxKind["Identifier"] = 65] = "Identifier"; - // Reserved words - SyntaxKind[SyntaxKind["BreakKeyword"] = 66] = "BreakKeyword"; - SyntaxKind[SyntaxKind["CaseKeyword"] = 67] = "CaseKeyword"; - SyntaxKind[SyntaxKind["CatchKeyword"] = 68] = "CatchKeyword"; - SyntaxKind[SyntaxKind["ClassKeyword"] = 69] = "ClassKeyword"; - SyntaxKind[SyntaxKind["ConstKeyword"] = 70] = "ConstKeyword"; - SyntaxKind[SyntaxKind["ContinueKeyword"] = 71] = "ContinueKeyword"; - SyntaxKind[SyntaxKind["DebuggerKeyword"] = 72] = "DebuggerKeyword"; - SyntaxKind[SyntaxKind["DefaultKeyword"] = 73] = "DefaultKeyword"; - SyntaxKind[SyntaxKind["DeleteKeyword"] = 74] = "DeleteKeyword"; - SyntaxKind[SyntaxKind["DoKeyword"] = 75] = "DoKeyword"; - SyntaxKind[SyntaxKind["ElseKeyword"] = 76] = "ElseKeyword"; - SyntaxKind[SyntaxKind["EnumKeyword"] = 77] = "EnumKeyword"; - SyntaxKind[SyntaxKind["ExportKeyword"] = 78] = "ExportKeyword"; - SyntaxKind[SyntaxKind["ExtendsKeyword"] = 79] = "ExtendsKeyword"; - SyntaxKind[SyntaxKind["FalseKeyword"] = 80] = "FalseKeyword"; - SyntaxKind[SyntaxKind["FinallyKeyword"] = 81] = "FinallyKeyword"; - SyntaxKind[SyntaxKind["ForKeyword"] = 82] = "ForKeyword"; - SyntaxKind[SyntaxKind["FunctionKeyword"] = 83] = "FunctionKeyword"; - SyntaxKind[SyntaxKind["IfKeyword"] = 84] = "IfKeyword"; - SyntaxKind[SyntaxKind["ImportKeyword"] = 85] = "ImportKeyword"; - SyntaxKind[SyntaxKind["InKeyword"] = 86] = "InKeyword"; - SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 87] = "InstanceOfKeyword"; - SyntaxKind[SyntaxKind["NewKeyword"] = 88] = "NewKeyword"; - SyntaxKind[SyntaxKind["NullKeyword"] = 89] = "NullKeyword"; - SyntaxKind[SyntaxKind["ReturnKeyword"] = 90] = "ReturnKeyword"; - SyntaxKind[SyntaxKind["SuperKeyword"] = 91] = "SuperKeyword"; - SyntaxKind[SyntaxKind["SwitchKeyword"] = 92] = "SwitchKeyword"; - SyntaxKind[SyntaxKind["ThisKeyword"] = 93] = "ThisKeyword"; - SyntaxKind[SyntaxKind["ThrowKeyword"] = 94] = "ThrowKeyword"; - SyntaxKind[SyntaxKind["TrueKeyword"] = 95] = "TrueKeyword"; - SyntaxKind[SyntaxKind["TryKeyword"] = 96] = "TryKeyword"; - SyntaxKind[SyntaxKind["TypeOfKeyword"] = 97] = "TypeOfKeyword"; - SyntaxKind[SyntaxKind["VarKeyword"] = 98] = "VarKeyword"; - SyntaxKind[SyntaxKind["VoidKeyword"] = 99] = "VoidKeyword"; - SyntaxKind[SyntaxKind["WhileKeyword"] = 100] = "WhileKeyword"; - SyntaxKind[SyntaxKind["WithKeyword"] = 101] = "WithKeyword"; - // Strict mode reserved words - SyntaxKind[SyntaxKind["ImplementsKeyword"] = 102] = "ImplementsKeyword"; - SyntaxKind[SyntaxKind["InterfaceKeyword"] = 103] = "InterfaceKeyword"; - SyntaxKind[SyntaxKind["LetKeyword"] = 104] = "LetKeyword"; - SyntaxKind[SyntaxKind["PackageKeyword"] = 105] = "PackageKeyword"; - SyntaxKind[SyntaxKind["PrivateKeyword"] = 106] = "PrivateKeyword"; - SyntaxKind[SyntaxKind["ProtectedKeyword"] = 107] = "ProtectedKeyword"; - SyntaxKind[SyntaxKind["PublicKeyword"] = 108] = "PublicKeyword"; - SyntaxKind[SyntaxKind["StaticKeyword"] = 109] = "StaticKeyword"; - SyntaxKind[SyntaxKind["YieldKeyword"] = 110] = "YieldKeyword"; - // Contextual keywords - SyntaxKind[SyntaxKind["AsKeyword"] = 111] = "AsKeyword"; - SyntaxKind[SyntaxKind["AnyKeyword"] = 112] = "AnyKeyword"; - SyntaxKind[SyntaxKind["BooleanKeyword"] = 113] = "BooleanKeyword"; - SyntaxKind[SyntaxKind["ConstructorKeyword"] = 114] = "ConstructorKeyword"; - SyntaxKind[SyntaxKind["DeclareKeyword"] = 115] = "DeclareKeyword"; - SyntaxKind[SyntaxKind["GetKeyword"] = 116] = "GetKeyword"; - SyntaxKind[SyntaxKind["ModuleKeyword"] = 117] = "ModuleKeyword"; - SyntaxKind[SyntaxKind["NamespaceKeyword"] = 118] = "NamespaceKeyword"; - SyntaxKind[SyntaxKind["RequireKeyword"] = 119] = "RequireKeyword"; - SyntaxKind[SyntaxKind["NumberKeyword"] = 120] = "NumberKeyword"; - SyntaxKind[SyntaxKind["SetKeyword"] = 121] = "SetKeyword"; - SyntaxKind[SyntaxKind["StringKeyword"] = 122] = "StringKeyword"; - SyntaxKind[SyntaxKind["SymbolKeyword"] = 123] = "SymbolKeyword"; - SyntaxKind[SyntaxKind["TypeKeyword"] = 124] = "TypeKeyword"; - SyntaxKind[SyntaxKind["FromKeyword"] = 125] = "FromKeyword"; - SyntaxKind[SyntaxKind["OfKeyword"] = 126] = "OfKeyword"; - // Parse tree nodes - // Names - SyntaxKind[SyntaxKind["QualifiedName"] = 127] = "QualifiedName"; - SyntaxKind[SyntaxKind["ComputedPropertyName"] = 128] = "ComputedPropertyName"; - // Signature elements - SyntaxKind[SyntaxKind["TypeParameter"] = 129] = "TypeParameter"; - SyntaxKind[SyntaxKind["Parameter"] = 130] = "Parameter"; - SyntaxKind[SyntaxKind["Decorator"] = 131] = "Decorator"; - // TypeMember - SyntaxKind[SyntaxKind["PropertySignature"] = 132] = "PropertySignature"; - SyntaxKind[SyntaxKind["PropertyDeclaration"] = 133] = "PropertyDeclaration"; - SyntaxKind[SyntaxKind["MethodSignature"] = 134] = "MethodSignature"; - SyntaxKind[SyntaxKind["MethodDeclaration"] = 135] = "MethodDeclaration"; - SyntaxKind[SyntaxKind["Constructor"] = 136] = "Constructor"; - SyntaxKind[SyntaxKind["GetAccessor"] = 137] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 138] = "SetAccessor"; - SyntaxKind[SyntaxKind["CallSignature"] = 139] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 140] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 141] = "IndexSignature"; - // Type - SyntaxKind[SyntaxKind["TypeReference"] = 142] = "TypeReference"; - SyntaxKind[SyntaxKind["FunctionType"] = 143] = "FunctionType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 144] = "ConstructorType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 145] = "TypeQuery"; - SyntaxKind[SyntaxKind["TypeLiteral"] = 146] = "TypeLiteral"; - SyntaxKind[SyntaxKind["ArrayType"] = 147] = "ArrayType"; - SyntaxKind[SyntaxKind["TupleType"] = 148] = "TupleType"; - SyntaxKind[SyntaxKind["UnionType"] = 149] = "UnionType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 150] = "ParenthesizedType"; - // Binding patterns - SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 151] = "ObjectBindingPattern"; - SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 152] = "ArrayBindingPattern"; - SyntaxKind[SyntaxKind["BindingElement"] = 153] = "BindingElement"; - // Expression - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 154] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 155] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 156] = "PropertyAccessExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 157] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["CallExpression"] = 158] = "CallExpression"; - SyntaxKind[SyntaxKind["NewExpression"] = 159] = "NewExpression"; - SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 160] = "TaggedTemplateExpression"; - SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 161] = "TypeAssertionExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 162] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 163] = "FunctionExpression"; - SyntaxKind[SyntaxKind["ArrowFunction"] = 164] = "ArrowFunction"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 165] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 166] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 167] = "VoidExpression"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 168] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 169] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 170] = "BinaryExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 171] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["TemplateExpression"] = 172] = "TemplateExpression"; - SyntaxKind[SyntaxKind["YieldExpression"] = 173] = "YieldExpression"; - SyntaxKind[SyntaxKind["SpreadElementExpression"] = 174] = "SpreadElementExpression"; - SyntaxKind[SyntaxKind["ClassExpression"] = 175] = "ClassExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 176] = "OmittedExpression"; - SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 177] = "ExpressionWithTypeArguments"; - // Misc - SyntaxKind[SyntaxKind["TemplateSpan"] = 178] = "TemplateSpan"; - SyntaxKind[SyntaxKind["SemicolonClassElement"] = 179] = "SemicolonClassElement"; - // Element - SyntaxKind[SyntaxKind["Block"] = 180] = "Block"; - SyntaxKind[SyntaxKind["VariableStatement"] = 181] = "VariableStatement"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 182] = "EmptyStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 183] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["IfStatement"] = 184] = "IfStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 185] = "DoStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 186] = "WhileStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 187] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 188] = "ForInStatement"; - SyntaxKind[SyntaxKind["ForOfStatement"] = 189] = "ForOfStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 190] = "ContinueStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 191] = "BreakStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 192] = "ReturnStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 193] = "WithStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 194] = "SwitchStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 195] = "LabeledStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 196] = "ThrowStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 197] = "TryStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 198] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 199] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarationList"] = 200] = "VariableDeclarationList"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 201] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 202] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 203] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 204] = "TypeAliasDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 205] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 206] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ModuleBlock"] = 207] = "ModuleBlock"; - SyntaxKind[SyntaxKind["CaseBlock"] = 208] = "CaseBlock"; - SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 209] = "ImportEqualsDeclaration"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 210] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ImportClause"] = 211] = "ImportClause"; - SyntaxKind[SyntaxKind["NamespaceImport"] = 212] = "NamespaceImport"; - SyntaxKind[SyntaxKind["NamedImports"] = 213] = "NamedImports"; - SyntaxKind[SyntaxKind["ImportSpecifier"] = 214] = "ImportSpecifier"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 215] = "ExportAssignment"; - SyntaxKind[SyntaxKind["ExportDeclaration"] = 216] = "ExportDeclaration"; - SyntaxKind[SyntaxKind["NamedExports"] = 217] = "NamedExports"; - SyntaxKind[SyntaxKind["ExportSpecifier"] = 218] = "ExportSpecifier"; - SyntaxKind[SyntaxKind["MissingDeclaration"] = 219] = "MissingDeclaration"; - // Module references - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 220] = "ExternalModuleReference"; - // Clauses - SyntaxKind[SyntaxKind["CaseClause"] = 221] = "CaseClause"; - SyntaxKind[SyntaxKind["DefaultClause"] = 222] = "DefaultClause"; - SyntaxKind[SyntaxKind["HeritageClause"] = 223] = "HeritageClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 224] = "CatchClause"; - // Property assignments - SyntaxKind[SyntaxKind["PropertyAssignment"] = 225] = "PropertyAssignment"; - SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 226] = "ShorthandPropertyAssignment"; - // Enum - SyntaxKind[SyntaxKind["EnumMember"] = 227] = "EnumMember"; - // Top-level nodes - SyntaxKind[SyntaxKind["SourceFile"] = 228] = "SourceFile"; - // Synthesized list - SyntaxKind[SyntaxKind["SyntaxList"] = 229] = "SyntaxList"; - // Enum value count - SyntaxKind[SyntaxKind["Count"] = 230] = "Count"; - // Markers - SyntaxKind[SyntaxKind["FirstAssignment"] = 53] = "FirstAssignment"; - SyntaxKind[SyntaxKind["LastAssignment"] = 64] = "LastAssignment"; - SyntaxKind[SyntaxKind["FirstReservedWord"] = 66] = "FirstReservedWord"; - SyntaxKind[SyntaxKind["LastReservedWord"] = 101] = "LastReservedWord"; - SyntaxKind[SyntaxKind["FirstKeyword"] = 66] = "FirstKeyword"; - SyntaxKind[SyntaxKind["LastKeyword"] = 126] = "LastKeyword"; - SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 102] = "FirstFutureReservedWord"; - SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 110] = "LastFutureReservedWord"; - SyntaxKind[SyntaxKind["FirstTypeNode"] = 142] = "FirstTypeNode"; - SyntaxKind[SyntaxKind["LastTypeNode"] = 150] = "LastTypeNode"; - SyntaxKind[SyntaxKind["FirstPunctuation"] = 14] = "FirstPunctuation"; - SyntaxKind[SyntaxKind["LastPunctuation"] = 64] = "LastPunctuation"; - SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken"; - SyntaxKind[SyntaxKind["LastToken"] = 126] = "LastToken"; - SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken"; - SyntaxKind[SyntaxKind["LastTriviaToken"] = 6] = "LastTriviaToken"; - SyntaxKind[SyntaxKind["FirstLiteralToken"] = 7] = "FirstLiteralToken"; - SyntaxKind[SyntaxKind["LastLiteralToken"] = 10] = "LastLiteralToken"; - SyntaxKind[SyntaxKind["FirstTemplateToken"] = 10] = "FirstTemplateToken"; - SyntaxKind[SyntaxKind["LastTemplateToken"] = 13] = "LastTemplateToken"; - SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 24] = "FirstBinaryOperator"; - SyntaxKind[SyntaxKind["LastBinaryOperator"] = 64] = "LastBinaryOperator"; - SyntaxKind[SyntaxKind["FirstNode"] = 127] = "FirstNode"; - })(ts.SyntaxKind || (ts.SyntaxKind = {})); - var SyntaxKind = ts.SyntaxKind; - (function (NodeFlags) { - NodeFlags[NodeFlags["Export"] = 1] = "Export"; - NodeFlags[NodeFlags["Ambient"] = 2] = "Ambient"; - NodeFlags[NodeFlags["Public"] = 16] = "Public"; - NodeFlags[NodeFlags["Private"] = 32] = "Private"; - NodeFlags[NodeFlags["Protected"] = 64] = "Protected"; - NodeFlags[NodeFlags["Static"] = 128] = "Static"; - NodeFlags[NodeFlags["Default"] = 256] = "Default"; - NodeFlags[NodeFlags["MultiLine"] = 512] = "MultiLine"; - NodeFlags[NodeFlags["Synthetic"] = 1024] = "Synthetic"; - NodeFlags[NodeFlags["DeclarationFile"] = 2048] = "DeclarationFile"; - NodeFlags[NodeFlags["Let"] = 4096] = "Let"; - NodeFlags[NodeFlags["Const"] = 8192] = "Const"; - NodeFlags[NodeFlags["OctalLiteral"] = 16384] = "OctalLiteral"; - NodeFlags[NodeFlags["Namespace"] = 32768] = "Namespace"; - NodeFlags[NodeFlags["ExportContext"] = 65536] = "ExportContext"; - NodeFlags[NodeFlags["Modifier"] = 499] = "Modifier"; - NodeFlags[NodeFlags["AccessibilityModifier"] = 112] = "AccessibilityModifier"; - NodeFlags[NodeFlags["BlockScoped"] = 12288] = "BlockScoped"; - })(ts.NodeFlags || (ts.NodeFlags = {})); - var NodeFlags = ts.NodeFlags; - /* @internal */ - (function (ParserContextFlags) { - // Set if this node was parsed in strict mode. Used for grammar error checks, as well as - // checking if the node can be reused in incremental settings. - ParserContextFlags[ParserContextFlags["StrictMode"] = 1] = "StrictMode"; - // If this node was parsed in a context where 'in-expressions' are not allowed. - ParserContextFlags[ParserContextFlags["DisallowIn"] = 2] = "DisallowIn"; - // If this node was parsed in the 'yield' context created when parsing a generator. - ParserContextFlags[ParserContextFlags["Yield"] = 4] = "Yield"; - // If this node was parsed in the parameters of a generator. - ParserContextFlags[ParserContextFlags["GeneratorParameter"] = 8] = "GeneratorParameter"; - // If this node was parsed as part of a decorator - ParserContextFlags[ParserContextFlags["Decorator"] = 16] = "Decorator"; - // If the parser encountered an error when parsing the code that created this node. Note - // the parser only sets this directly on the node it creates right after encountering the - // error. - ParserContextFlags[ParserContextFlags["ThisNodeHasError"] = 32] = "ThisNodeHasError"; - // Context flags set directly by the parser. - ParserContextFlags[ParserContextFlags["ParserGeneratedFlags"] = 63] = "ParserGeneratedFlags"; - // Context flags computed by aggregating child flags upwards. - // Used during incremental parsing to determine if this node or any of its children had an - // error. Computed only once and then cached. - ParserContextFlags[ParserContextFlags["ThisNodeOrAnySubNodesHasError"] = 64] = "ThisNodeOrAnySubNodesHasError"; - // Used to know if we've computed data from children and cached it in this node. - ParserContextFlags[ParserContextFlags["HasAggregatedChildData"] = 128] = "HasAggregatedChildData"; - })(ts.ParserContextFlags || (ts.ParserContextFlags = {})); - var ParserContextFlags = ts.ParserContextFlags; - /* @internal */ - (function (RelationComparisonResult) { - RelationComparisonResult[RelationComparisonResult["Succeeded"] = 1] = "Succeeded"; - RelationComparisonResult[RelationComparisonResult["Failed"] = 2] = "Failed"; - RelationComparisonResult[RelationComparisonResult["FailedAndReported"] = 3] = "FailedAndReported"; - })(ts.RelationComparisonResult || (ts.RelationComparisonResult = {})); - var RelationComparisonResult = ts.RelationComparisonResult; - /** Return code used by getEmitOutput function to indicate status of the function */ (function (ExitStatus) { - // Compiler ran successfully. Either this was a simple do-nothing compilation (for example, - // when -version or -help was provided, or this was a normal compilation, no diagnostics - // were produced, and all outputs were generated successfully. ExitStatus[ExitStatus["Success"] = 0] = "Success"; - // Diagnostics were produced and because of them no code was generated. ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped"; - // Diagnostics were produced and outputs were generated in spite of them. ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated"; })(ts.ExitStatus || (ts.ExitStatus = {})); var ExitStatus = ts.ExitStatus; - (function (TypeFormatFlags) { - TypeFormatFlags[TypeFormatFlags["None"] = 0] = "None"; - TypeFormatFlags[TypeFormatFlags["WriteArrayAsGenericType"] = 1] = "WriteArrayAsGenericType"; - TypeFormatFlags[TypeFormatFlags["UseTypeOfFunction"] = 2] = "UseTypeOfFunction"; - TypeFormatFlags[TypeFormatFlags["NoTruncation"] = 4] = "NoTruncation"; - TypeFormatFlags[TypeFormatFlags["WriteArrowStyleSignature"] = 8] = "WriteArrowStyleSignature"; - TypeFormatFlags[TypeFormatFlags["WriteOwnNameForAnyLike"] = 16] = "WriteOwnNameForAnyLike"; - TypeFormatFlags[TypeFormatFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature"; - TypeFormatFlags[TypeFormatFlags["InElementType"] = 64] = "InElementType"; - TypeFormatFlags[TypeFormatFlags["UseFullyQualifiedType"] = 128] = "UseFullyQualifiedType"; - })(ts.TypeFormatFlags || (ts.TypeFormatFlags = {})); - var TypeFormatFlags = ts.TypeFormatFlags; - (function (SymbolFormatFlags) { - SymbolFormatFlags[SymbolFormatFlags["None"] = 0] = "None"; - // Write symbols's type argument if it is instantiated symbol - // eg. class C { p: T } <-- Show p as C.p here - // var a: C; - // var p = a.p; <--- Here p is property of C so show it as C.p instead of just C.p - SymbolFormatFlags[SymbolFormatFlags["WriteTypeParametersOrArguments"] = 1] = "WriteTypeParametersOrArguments"; - // Use only external alias information to get the symbol name in the given context - // eg. module m { export class c { } } import x = m.c; - // When this flag is specified m.c will be used to refer to the class instead of alias symbol x - SymbolFormatFlags[SymbolFormatFlags["UseOnlyExternalAliasing"] = 2] = "UseOnlyExternalAliasing"; - })(ts.SymbolFormatFlags || (ts.SymbolFormatFlags = {})); - var SymbolFormatFlags = ts.SymbolFormatFlags; - /* @internal */ - (function (SymbolAccessibility) { - SymbolAccessibility[SymbolAccessibility["Accessible"] = 0] = "Accessible"; - SymbolAccessibility[SymbolAccessibility["NotAccessible"] = 1] = "NotAccessible"; - SymbolAccessibility[SymbolAccessibility["CannotBeNamed"] = 2] = "CannotBeNamed"; - })(ts.SymbolAccessibility || (ts.SymbolAccessibility = {})); - var SymbolAccessibility = ts.SymbolAccessibility; - (function (SymbolFlags) { - SymbolFlags[SymbolFlags["FunctionScopedVariable"] = 1] = "FunctionScopedVariable"; - SymbolFlags[SymbolFlags["BlockScopedVariable"] = 2] = "BlockScopedVariable"; - SymbolFlags[SymbolFlags["Property"] = 4] = "Property"; - SymbolFlags[SymbolFlags["EnumMember"] = 8] = "EnumMember"; - SymbolFlags[SymbolFlags["Function"] = 16] = "Function"; - SymbolFlags[SymbolFlags["Class"] = 32] = "Class"; - SymbolFlags[SymbolFlags["Interface"] = 64] = "Interface"; - SymbolFlags[SymbolFlags["ConstEnum"] = 128] = "ConstEnum"; - SymbolFlags[SymbolFlags["RegularEnum"] = 256] = "RegularEnum"; - SymbolFlags[SymbolFlags["ValueModule"] = 512] = "ValueModule"; - SymbolFlags[SymbolFlags["NamespaceModule"] = 1024] = "NamespaceModule"; - SymbolFlags[SymbolFlags["TypeLiteral"] = 2048] = "TypeLiteral"; - SymbolFlags[SymbolFlags["ObjectLiteral"] = 4096] = "ObjectLiteral"; - SymbolFlags[SymbolFlags["Method"] = 8192] = "Method"; - SymbolFlags[SymbolFlags["Constructor"] = 16384] = "Constructor"; - SymbolFlags[SymbolFlags["GetAccessor"] = 32768] = "GetAccessor"; - SymbolFlags[SymbolFlags["SetAccessor"] = 65536] = "SetAccessor"; - SymbolFlags[SymbolFlags["Signature"] = 131072] = "Signature"; - SymbolFlags[SymbolFlags["TypeParameter"] = 262144] = "TypeParameter"; - SymbolFlags[SymbolFlags["TypeAlias"] = 524288] = "TypeAlias"; - SymbolFlags[SymbolFlags["ExportValue"] = 1048576] = "ExportValue"; - SymbolFlags[SymbolFlags["ExportType"] = 2097152] = "ExportType"; - SymbolFlags[SymbolFlags["ExportNamespace"] = 4194304] = "ExportNamespace"; - SymbolFlags[SymbolFlags["Alias"] = 8388608] = "Alias"; - SymbolFlags[SymbolFlags["Instantiated"] = 16777216] = "Instantiated"; - SymbolFlags[SymbolFlags["Merged"] = 33554432] = "Merged"; - SymbolFlags[SymbolFlags["Transient"] = 67108864] = "Transient"; - SymbolFlags[SymbolFlags["Prototype"] = 134217728] = "Prototype"; - SymbolFlags[SymbolFlags["UnionProperty"] = 268435456] = "UnionProperty"; - SymbolFlags[SymbolFlags["Optional"] = 536870912] = "Optional"; - SymbolFlags[SymbolFlags["ExportStar"] = 1073741824] = "ExportStar"; - SymbolFlags[SymbolFlags["Enum"] = 384] = "Enum"; - SymbolFlags[SymbolFlags["Variable"] = 3] = "Variable"; - SymbolFlags[SymbolFlags["Value"] = 107455] = "Value"; - SymbolFlags[SymbolFlags["Type"] = 793056] = "Type"; - SymbolFlags[SymbolFlags["Namespace"] = 1536] = "Namespace"; - SymbolFlags[SymbolFlags["Module"] = 1536] = "Module"; - SymbolFlags[SymbolFlags["Accessor"] = 98304] = "Accessor"; - // Variables can be redeclared, but can not redeclare a block-scoped declaration with the - // same name, or any other value that is not a variable, e.g. ValueModule or Class - SymbolFlags[SymbolFlags["FunctionScopedVariableExcludes"] = 107454] = "FunctionScopedVariableExcludes"; - // Block-scoped declarations are not allowed to be re-declared - // they can not merge with anything in the value space - SymbolFlags[SymbolFlags["BlockScopedVariableExcludes"] = 107455] = "BlockScopedVariableExcludes"; - SymbolFlags[SymbolFlags["ParameterExcludes"] = 107455] = "ParameterExcludes"; - SymbolFlags[SymbolFlags["PropertyExcludes"] = 107455] = "PropertyExcludes"; - SymbolFlags[SymbolFlags["EnumMemberExcludes"] = 107455] = "EnumMemberExcludes"; - SymbolFlags[SymbolFlags["FunctionExcludes"] = 106927] = "FunctionExcludes"; - SymbolFlags[SymbolFlags["ClassExcludes"] = 899583] = "ClassExcludes"; - SymbolFlags[SymbolFlags["InterfaceExcludes"] = 792992] = "InterfaceExcludes"; - SymbolFlags[SymbolFlags["RegularEnumExcludes"] = 899327] = "RegularEnumExcludes"; - SymbolFlags[SymbolFlags["ConstEnumExcludes"] = 899967] = "ConstEnumExcludes"; - SymbolFlags[SymbolFlags["ValueModuleExcludes"] = 106639] = "ValueModuleExcludes"; - SymbolFlags[SymbolFlags["NamespaceModuleExcludes"] = 0] = "NamespaceModuleExcludes"; - SymbolFlags[SymbolFlags["MethodExcludes"] = 99263] = "MethodExcludes"; - SymbolFlags[SymbolFlags["GetAccessorExcludes"] = 41919] = "GetAccessorExcludes"; - SymbolFlags[SymbolFlags["SetAccessorExcludes"] = 74687] = "SetAccessorExcludes"; - SymbolFlags[SymbolFlags["TypeParameterExcludes"] = 530912] = "TypeParameterExcludes"; - SymbolFlags[SymbolFlags["TypeAliasExcludes"] = 793056] = "TypeAliasExcludes"; - SymbolFlags[SymbolFlags["AliasExcludes"] = 8388608] = "AliasExcludes"; - SymbolFlags[SymbolFlags["ModuleMember"] = 8914931] = "ModuleMember"; - SymbolFlags[SymbolFlags["ExportHasLocal"] = 944] = "ExportHasLocal"; - SymbolFlags[SymbolFlags["HasLocals"] = 255504] = "HasLocals"; - SymbolFlags[SymbolFlags["HasExports"] = 1952] = "HasExports"; - SymbolFlags[SymbolFlags["HasMembers"] = 6240] = "HasMembers"; - SymbolFlags[SymbolFlags["IsContainer"] = 262128] = "IsContainer"; - SymbolFlags[SymbolFlags["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor"; - SymbolFlags[SymbolFlags["Export"] = 7340032] = "Export"; - })(ts.SymbolFlags || (ts.SymbolFlags = {})); - var SymbolFlags = ts.SymbolFlags; - /* @internal */ - (function (NodeCheckFlags) { - NodeCheckFlags[NodeCheckFlags["TypeChecked"] = 1] = "TypeChecked"; - NodeCheckFlags[NodeCheckFlags["LexicalThis"] = 2] = "LexicalThis"; - NodeCheckFlags[NodeCheckFlags["CaptureThis"] = 4] = "CaptureThis"; - NodeCheckFlags[NodeCheckFlags["EmitExtends"] = 8] = "EmitExtends"; - NodeCheckFlags[NodeCheckFlags["SuperInstance"] = 16] = "SuperInstance"; - NodeCheckFlags[NodeCheckFlags["SuperStatic"] = 32] = "SuperStatic"; - NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 64] = "ContextChecked"; - // Values for enum members have been computed, and any errors have been reported for them. - NodeCheckFlags[NodeCheckFlags["EnumValuesComputed"] = 128] = "EnumValuesComputed"; - NodeCheckFlags[NodeCheckFlags["BlockScopedBindingInLoop"] = 256] = "BlockScopedBindingInLoop"; - NodeCheckFlags[NodeCheckFlags["EmitDecorate"] = 512] = "EmitDecorate"; - NodeCheckFlags[NodeCheckFlags["EmitParam"] = 1024] = "EmitParam"; - NodeCheckFlags[NodeCheckFlags["LexicalModuleMergesWithClass"] = 2048] = "LexicalModuleMergesWithClass"; - })(ts.NodeCheckFlags || (ts.NodeCheckFlags = {})); - var NodeCheckFlags = ts.NodeCheckFlags; - (function (TypeFlags) { - TypeFlags[TypeFlags["Any"] = 1] = "Any"; - TypeFlags[TypeFlags["String"] = 2] = "String"; - TypeFlags[TypeFlags["Number"] = 4] = "Number"; - TypeFlags[TypeFlags["Boolean"] = 8] = "Boolean"; - TypeFlags[TypeFlags["Void"] = 16] = "Void"; - TypeFlags[TypeFlags["Undefined"] = 32] = "Undefined"; - TypeFlags[TypeFlags["Null"] = 64] = "Null"; - TypeFlags[TypeFlags["Enum"] = 128] = "Enum"; - TypeFlags[TypeFlags["StringLiteral"] = 256] = "StringLiteral"; - TypeFlags[TypeFlags["TypeParameter"] = 512] = "TypeParameter"; - TypeFlags[TypeFlags["Class"] = 1024] = "Class"; - TypeFlags[TypeFlags["Interface"] = 2048] = "Interface"; - TypeFlags[TypeFlags["Reference"] = 4096] = "Reference"; - TypeFlags[TypeFlags["Tuple"] = 8192] = "Tuple"; - TypeFlags[TypeFlags["Union"] = 16384] = "Union"; - TypeFlags[TypeFlags["Anonymous"] = 32768] = "Anonymous"; - /* @internal */ - TypeFlags[TypeFlags["FromSignature"] = 65536] = "FromSignature"; - TypeFlags[TypeFlags["ObjectLiteral"] = 131072] = "ObjectLiteral"; - /* @internal */ - TypeFlags[TypeFlags["ContainsUndefinedOrNull"] = 262144] = "ContainsUndefinedOrNull"; - /* @internal */ - TypeFlags[TypeFlags["ContainsObjectLiteral"] = 524288] = "ContainsObjectLiteral"; - TypeFlags[TypeFlags["ESSymbol"] = 1048576] = "ESSymbol"; - /* @internal */ - TypeFlags[TypeFlags["Intrinsic"] = 1048703] = "Intrinsic"; - /* @internal */ - TypeFlags[TypeFlags["Primitive"] = 1049086] = "Primitive"; - TypeFlags[TypeFlags["StringLike"] = 258] = "StringLike"; - TypeFlags[TypeFlags["NumberLike"] = 132] = "NumberLike"; - TypeFlags[TypeFlags["ObjectType"] = 48128] = "ObjectType"; - /* @internal */ - TypeFlags[TypeFlags["RequiresWidening"] = 786432] = "RequiresWidening"; - })(ts.TypeFlags || (ts.TypeFlags = {})); - var TypeFlags = ts.TypeFlags; - (function (SignatureKind) { - SignatureKind[SignatureKind["Call"] = 0] = "Call"; - SignatureKind[SignatureKind["Construct"] = 1] = "Construct"; - })(ts.SignatureKind || (ts.SignatureKind = {})); - var SignatureKind = ts.SignatureKind; - (function (IndexKind) { - IndexKind[IndexKind["String"] = 0] = "String"; - IndexKind[IndexKind["Number"] = 1] = "Number"; - })(ts.IndexKind || (ts.IndexKind = {})); - var IndexKind = ts.IndexKind; (function (DiagnosticCategory) { DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message"; })(ts.DiagnosticCategory || (ts.DiagnosticCategory = {})); var DiagnosticCategory = ts.DiagnosticCategory; - (function (ModuleKind) { - ModuleKind[ModuleKind["None"] = 0] = "None"; - ModuleKind[ModuleKind["CommonJS"] = 1] = "CommonJS"; - ModuleKind[ModuleKind["AMD"] = 2] = "AMD"; - ModuleKind[ModuleKind["UMD"] = 3] = "UMD"; - ModuleKind[ModuleKind["System"] = 4] = "System"; - })(ts.ModuleKind || (ts.ModuleKind = {})); - var ModuleKind = ts.ModuleKind; - (function (ScriptTarget) { - ScriptTarget[ScriptTarget["ES3"] = 0] = "ES3"; - ScriptTarget[ScriptTarget["ES5"] = 1] = "ES5"; - ScriptTarget[ScriptTarget["ES6"] = 2] = "ES6"; - ScriptTarget[ScriptTarget["Latest"] = 2] = "Latest"; - })(ts.ScriptTarget || (ts.ScriptTarget = {})); - var ScriptTarget = ts.ScriptTarget; - /* @internal */ - (function (CharacterCodes) { - CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter"; - CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter"; - CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed"; - CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn"; - CharacterCodes[CharacterCodes["lineSeparator"] = 8232] = "lineSeparator"; - CharacterCodes[CharacterCodes["paragraphSeparator"] = 8233] = "paragraphSeparator"; - CharacterCodes[CharacterCodes["nextLine"] = 133] = "nextLine"; - // Unicode 3.0 space characters - CharacterCodes[CharacterCodes["space"] = 32] = "space"; - CharacterCodes[CharacterCodes["nonBreakingSpace"] = 160] = "nonBreakingSpace"; - CharacterCodes[CharacterCodes["enQuad"] = 8192] = "enQuad"; - CharacterCodes[CharacterCodes["emQuad"] = 8193] = "emQuad"; - CharacterCodes[CharacterCodes["enSpace"] = 8194] = "enSpace"; - CharacterCodes[CharacterCodes["emSpace"] = 8195] = "emSpace"; - CharacterCodes[CharacterCodes["threePerEmSpace"] = 8196] = "threePerEmSpace"; - CharacterCodes[CharacterCodes["fourPerEmSpace"] = 8197] = "fourPerEmSpace"; - CharacterCodes[CharacterCodes["sixPerEmSpace"] = 8198] = "sixPerEmSpace"; - CharacterCodes[CharacterCodes["figureSpace"] = 8199] = "figureSpace"; - CharacterCodes[CharacterCodes["punctuationSpace"] = 8200] = "punctuationSpace"; - CharacterCodes[CharacterCodes["thinSpace"] = 8201] = "thinSpace"; - CharacterCodes[CharacterCodes["hairSpace"] = 8202] = "hairSpace"; - CharacterCodes[CharacterCodes["zeroWidthSpace"] = 8203] = "zeroWidthSpace"; - CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 8239] = "narrowNoBreakSpace"; - CharacterCodes[CharacterCodes["ideographicSpace"] = 12288] = "ideographicSpace"; - CharacterCodes[CharacterCodes["mathematicalSpace"] = 8287] = "mathematicalSpace"; - CharacterCodes[CharacterCodes["ogham"] = 5760] = "ogham"; - CharacterCodes[CharacterCodes["_"] = 95] = "_"; - CharacterCodes[CharacterCodes["$"] = 36] = "$"; - CharacterCodes[CharacterCodes["_0"] = 48] = "_0"; - CharacterCodes[CharacterCodes["_1"] = 49] = "_1"; - CharacterCodes[CharacterCodes["_2"] = 50] = "_2"; - CharacterCodes[CharacterCodes["_3"] = 51] = "_3"; - CharacterCodes[CharacterCodes["_4"] = 52] = "_4"; - CharacterCodes[CharacterCodes["_5"] = 53] = "_5"; - CharacterCodes[CharacterCodes["_6"] = 54] = "_6"; - CharacterCodes[CharacterCodes["_7"] = 55] = "_7"; - CharacterCodes[CharacterCodes["_8"] = 56] = "_8"; - CharacterCodes[CharacterCodes["_9"] = 57] = "_9"; - CharacterCodes[CharacterCodes["a"] = 97] = "a"; - CharacterCodes[CharacterCodes["b"] = 98] = "b"; - CharacterCodes[CharacterCodes["c"] = 99] = "c"; - CharacterCodes[CharacterCodes["d"] = 100] = "d"; - CharacterCodes[CharacterCodes["e"] = 101] = "e"; - CharacterCodes[CharacterCodes["f"] = 102] = "f"; - CharacterCodes[CharacterCodes["g"] = 103] = "g"; - CharacterCodes[CharacterCodes["h"] = 104] = "h"; - CharacterCodes[CharacterCodes["i"] = 105] = "i"; - CharacterCodes[CharacterCodes["j"] = 106] = "j"; - CharacterCodes[CharacterCodes["k"] = 107] = "k"; - CharacterCodes[CharacterCodes["l"] = 108] = "l"; - CharacterCodes[CharacterCodes["m"] = 109] = "m"; - CharacterCodes[CharacterCodes["n"] = 110] = "n"; - CharacterCodes[CharacterCodes["o"] = 111] = "o"; - CharacterCodes[CharacterCodes["p"] = 112] = "p"; - CharacterCodes[CharacterCodes["q"] = 113] = "q"; - CharacterCodes[CharacterCodes["r"] = 114] = "r"; - CharacterCodes[CharacterCodes["s"] = 115] = "s"; - CharacterCodes[CharacterCodes["t"] = 116] = "t"; - CharacterCodes[CharacterCodes["u"] = 117] = "u"; - CharacterCodes[CharacterCodes["v"] = 118] = "v"; - CharacterCodes[CharacterCodes["w"] = 119] = "w"; - CharacterCodes[CharacterCodes["x"] = 120] = "x"; - CharacterCodes[CharacterCodes["y"] = 121] = "y"; - CharacterCodes[CharacterCodes["z"] = 122] = "z"; - CharacterCodes[CharacterCodes["A"] = 65] = "A"; - CharacterCodes[CharacterCodes["B"] = 66] = "B"; - CharacterCodes[CharacterCodes["C"] = 67] = "C"; - CharacterCodes[CharacterCodes["D"] = 68] = "D"; - CharacterCodes[CharacterCodes["E"] = 69] = "E"; - CharacterCodes[CharacterCodes["F"] = 70] = "F"; - CharacterCodes[CharacterCodes["G"] = 71] = "G"; - CharacterCodes[CharacterCodes["H"] = 72] = "H"; - CharacterCodes[CharacterCodes["I"] = 73] = "I"; - CharacterCodes[CharacterCodes["J"] = 74] = "J"; - CharacterCodes[CharacterCodes["K"] = 75] = "K"; - CharacterCodes[CharacterCodes["L"] = 76] = "L"; - CharacterCodes[CharacterCodes["M"] = 77] = "M"; - CharacterCodes[CharacterCodes["N"] = 78] = "N"; - CharacterCodes[CharacterCodes["O"] = 79] = "O"; - CharacterCodes[CharacterCodes["P"] = 80] = "P"; - CharacterCodes[CharacterCodes["Q"] = 81] = "Q"; - CharacterCodes[CharacterCodes["R"] = 82] = "R"; - CharacterCodes[CharacterCodes["S"] = 83] = "S"; - CharacterCodes[CharacterCodes["T"] = 84] = "T"; - CharacterCodes[CharacterCodes["U"] = 85] = "U"; - CharacterCodes[CharacterCodes["V"] = 86] = "V"; - CharacterCodes[CharacterCodes["W"] = 87] = "W"; - CharacterCodes[CharacterCodes["X"] = 88] = "X"; - CharacterCodes[CharacterCodes["Y"] = 89] = "Y"; - CharacterCodes[CharacterCodes["Z"] = 90] = "Z"; - CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand"; - CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk"; - CharacterCodes[CharacterCodes["at"] = 64] = "at"; - CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash"; - CharacterCodes[CharacterCodes["backtick"] = 96] = "backtick"; - CharacterCodes[CharacterCodes["bar"] = 124] = "bar"; - CharacterCodes[CharacterCodes["caret"] = 94] = "caret"; - CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace"; - CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket"; - CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen"; - CharacterCodes[CharacterCodes["colon"] = 58] = "colon"; - CharacterCodes[CharacterCodes["comma"] = 44] = "comma"; - CharacterCodes[CharacterCodes["dot"] = 46] = "dot"; - CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote"; - CharacterCodes[CharacterCodes["equals"] = 61] = "equals"; - CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation"; - CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan"; - CharacterCodes[CharacterCodes["hash"] = 35] = "hash"; - CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan"; - CharacterCodes[CharacterCodes["minus"] = 45] = "minus"; - CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace"; - CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket"; - CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen"; - CharacterCodes[CharacterCodes["percent"] = 37] = "percent"; - CharacterCodes[CharacterCodes["plus"] = 43] = "plus"; - CharacterCodes[CharacterCodes["question"] = 63] = "question"; - CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon"; - CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote"; - CharacterCodes[CharacterCodes["slash"] = 47] = "slash"; - CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde"; - CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace"; - CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed"; - CharacterCodes[CharacterCodes["byteOrderMark"] = 65279] = "byteOrderMark"; - CharacterCodes[CharacterCodes["tab"] = 9] = "tab"; - CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab"; - })(ts.CharacterCodes || (ts.CharacterCodes = {})); - var CharacterCodes = ts.CharacterCodes; })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { - // Ternary values are defined such that - // x & y is False if either x or y is False. - // x & y is Maybe if either x or y is Maybe, but neither x or y is False. - // x & y is True if both x and y are True. - // x | y is False if both x and y are False. - // x | y is Maybe if either x or y is Maybe, but neither x or y is True. - // x | y is True if either x or y is True. - (function (Ternary) { - Ternary[Ternary["False"] = 0] = "False"; - Ternary[Ternary["Maybe"] = 1] = "Maybe"; - Ternary[Ternary["True"] = -1] = "True"; - })(ts.Ternary || (ts.Ternary = {})); - var Ternary = ts.Ternary; - (function (Comparison) { - Comparison[Comparison["LessThan"] = -1] = "LessThan"; - Comparison[Comparison["EqualTo"] = 0] = "EqualTo"; - Comparison[Comparison["GreaterThan"] = 1] = "GreaterThan"; - })(ts.Comparison || (ts.Comparison = {})); - var Comparison = ts.Comparison; function forEach(array, callback) { if (array) { for (var i = 0, len = array.length; i < len; i++) { @@ -806,9 +145,6 @@ var ts; } } ts.addRange = addRange; - /** - * Returns the last element of an array if non-empty, undefined otherwise. - */ function lastOrUndefined(array) { if (array.length === 0) { return undefined; @@ -931,16 +267,6 @@ var ts; } } ts.copyMap = copyMap; - /** - * Creates a map from the elements of an array. - * - * @param array the array of input elements. - * @param makeKey a function that produces a key for a given element. - * - * This function makes no effort to avoid collisions; if any two elements produce - * the same key with the given 'makeKey' function, then the element with the higher - * index in the array will be the one associated with the produced key. - */ function arrayToMap(array, makeKey) { var result = {}; forEach(array, function (value) { @@ -1027,12 +353,12 @@ var ts; ts.concatenateDiagnosticMessageChains = concatenateDiagnosticMessageChains; function compareValues(a, b) { if (a === b) - return 0 /* EqualTo */; + return 0; if (a === undefined) - return -1 /* LessThan */; + return -1; if (b === undefined) - return 1 /* GreaterThan */; - return a < b ? -1 /* LessThan */ : 1 /* GreaterThan */; + return 1; + return a < b ? -1 : 1; } ts.compareValues = compareValues; function getDiagnosticFileName(diagnostic) { @@ -1044,12 +370,11 @@ var ts; compareValues(d1.length, d2.length) || compareValues(d1.code, d2.code) || compareMessageText(d1.messageText, d2.messageText) || - 0 /* EqualTo */; + 0; } ts.compareDiagnostics = compareDiagnostics; function compareMessageText(text1, text2) { while (text1 && text2) { - // We still have both chains. var string1 = typeof text1 === "string" ? text1 : text1.messageText; var string2 = typeof text2 === "string" ? text2 : text2.messageText; var res = compareValues(string1, string2); @@ -1060,11 +385,9 @@ var ts; text2 = typeof text2 === "string" ? undefined : text2.next; } if (!text1 && !text2) { - // if the chains are done, then these messages are the same. - return 0 /* EqualTo */; + return 0; } - // We still have one chain remaining. The shorter chain should come first. - return text1 ? 1 /* GreaterThan */ : -1 /* LessThan */; + return text1 ? 1 : -1; } function sortAndDeduplicateDiagnostics(diagnostics) { return deduplicateSortedDiagnostics(diagnostics.sort(compareDiagnostics)); @@ -1078,7 +401,7 @@ var ts; var previousDiagnostic = diagnostics[0]; for (var i = 1; i < diagnostics.length; i++) { var currentDiagnostic = diagnostics[i]; - var isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === 0 /* EqualTo */; + var isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === 0; if (!isDupe) { newDiagnostics.push(currentDiagnostic); previousDiagnostic = currentDiagnostic; @@ -1091,10 +414,9 @@ var ts; return path.replace(/\\/g, "/"); } ts.normalizeSlashes = normalizeSlashes; - // Returns length of path root (i.e. length of "/", "x:/", "//server/share/, file:///user/files") function getRootLength(path) { - if (path.charCodeAt(0) === 47 /* slash */) { - if (path.charCodeAt(1) !== 47 /* slash */) + if (path.charCodeAt(0) === 47) { + if (path.charCodeAt(1) !== 47) return 1; var p1 = path.indexOf("/", 2); if (p1 < 0) @@ -1104,8 +426,8 @@ var ts; return p1 + 1; return p2 + 1; } - if (path.charCodeAt(1) === 58 /* colon */) { - if (path.charCodeAt(2) === 47 /* slash */) + if (path.charCodeAt(1) === 58) { + if (path.charCodeAt(2) === 47) return 3; return 2; } @@ -1122,12 +444,10 @@ var ts; for (var _i = 0; _i < parts.length; _i++) { var part = parts[_i]; if (part !== ".") { - if (part === ".." && normalized.length > 0 && normalized[normalized.length - 1] !== "..") { + if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") { normalized.pop(); } else { - // A part may be an empty string (which is 'falsy') if the path had consecutive slashes, - // e.g. "path//file.ts". Drop these before re-joining the parts. if (part) { normalized.push(part); } @@ -1163,7 +483,6 @@ var ts; path = normalizeSlashes(path); var rootLength = getRootLength(path); if (rootLength == 0) { - // If the path is not rooted it is relative to current directory path = combinePaths(normalizeSlashes(currentDirectory), path); rootLength = getRootLength(path); } @@ -1185,36 +504,24 @@ var ts; // In this example the root is: http://www.website.com/ // normalized path components should be ["http://www.website.com/", "folder1", "folder2"] var urlLength = url.length; - // Initial root length is http:// part var rootLength = url.indexOf("://") + "://".length; while (rootLength < urlLength) { - // Consume all immediate slashes in the protocol - // eg.initial rootlength is just file:// but it needs to consume another "/" in file:/// - if (url.charCodeAt(rootLength) === 47 /* slash */) { + if (url.charCodeAt(rootLength) === 47) { rootLength++; } else { - // non slash character means we continue proceeding to next component of root search break; } } - // there are no parts after http:// just return current string as the pathComponent if (rootLength === urlLength) { return [url]; } - // Find the index of "/" after website.com so the root can be http://www.website.com/ (from existing http://) var indexOfNextSlash = url.indexOf(ts.directorySeparator, rootLength); if (indexOfNextSlash !== -1) { - // Found the "/" after the website.com so the root is length of http://www.website.com/ - // and get components afetr the root normally like any other folder components rootLength = indexOfNextSlash + 1; return normalizedPathComponents(url, rootLength); } else { - // Can't find the host assume the rest of the string as component - // but make sure we append "/" to it as root is not joined using "/" - // eg. if url passed in was http://website.com we want to use root as [http://website.com/] - // so that other path manipulations will be correct and it can be merged with relative paths correctly return [url + ts.directorySeparator]; } } @@ -1229,18 +536,14 @@ var ts; function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) { var pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory); var directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory); - if (directoryComponents.length > 1 && directoryComponents[directoryComponents.length - 1] === "") { - // If the directory path given was of type test/cases/ then we really need components of directory to be only till its name - // that is ["test", "cases", ""] needs to be actually ["test", "cases"] + if (directoryComponents.length > 1 && lastOrUndefined(directoryComponents) === "") { directoryComponents.length--; } - // Find the component that differs for (var joinStartIndex = 0; joinStartIndex < pathComponents.length && joinStartIndex < directoryComponents.length; joinStartIndex++) { if (getCanonicalFileName(directoryComponents[joinStartIndex]) !== getCanonicalFileName(pathComponents[joinStartIndex])) { break; } } - // Get the relative path if (joinStartIndex) { var relativePath = ""; var relativePathComponents = pathComponents.slice(joinStartIndex, pathComponents.length); @@ -1251,7 +554,6 @@ var ts; } return relativePath + relativePathComponents.join(ts.directorySeparator); } - // Cant find the relative path, get the absolute path var absolutePath = getNormalizedPathFromPathComponents(pathComponents); if (isAbsolutePathAnUrl && isRootedDiskPath(absolutePath)) { absolutePath = "file:///" + absolutePath; @@ -1307,7 +609,7 @@ var ts; "\"": "\\\"", "\u2028": "\\u2028", "\u2029": "\\u2029", - "\u0085": "\\u0085" // nextLine + "\u0085": "\\u0085" }; function Symbol(flags, name) { this.flags = flags; @@ -1336,16 +638,9 @@ var ts; getTypeConstructor: function () { return Type; }, getSignatureConstructor: function () { return Signature; } }; - (function (AssertionLevel) { - AssertionLevel[AssertionLevel["None"] = 0] = "None"; - AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal"; - AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive"; - AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive"; - })(ts.AssertionLevel || (ts.AssertionLevel = {})); - var AssertionLevel = ts.AssertionLevel; var Debug; (function (Debug) { - var currentAssertionLevel = 0 /* None */; + var currentAssertionLevel = 0; function shouldAssert(level) { return currentAssertionLevel >= level; } @@ -1373,9 +668,9 @@ var ts; function getWScriptSystem() { var fso = new ActiveXObject("Scripting.FileSystemObject"); var fileStream = new ActiveXObject("ADODB.Stream"); - fileStream.Type = 2 /*text*/; + fileStream.Type = 2; var binaryStream = new ActiveXObject("ADODB.Stream"); - binaryStream.Type = 1 /*binary*/; + binaryStream.Type = 1; var args = []; for (var i = 0; i < WScript.Arguments.length; i++) { args[i] = WScript.Arguments.Item(i); @@ -1391,16 +686,12 @@ var ts; fileStream.LoadFromFile(fileName); } else { - // Load file and read the first two bytes into a string with no interpretation fileStream.Charset = "x-ansi"; fileStream.LoadFromFile(fileName); var bom = fileStream.ReadText(2) || ""; - // Position must be at 0 before encoding can be changed fileStream.Position = 0; - // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8 fileStream.Charset = bom.length >= 2 && (bom.charCodeAt(0) === 0xFF && bom.charCodeAt(1) === 0xFE || bom.charCodeAt(0) === 0xFE && bom.charCodeAt(1) === 0xFF) ? "unicode" : "utf-8"; } - // ReadText method always strips byte order mark from resulting string return fileStream.ReadText(); } catch (e) { @@ -1414,11 +705,8 @@ var ts; fileStream.Open(); binaryStream.Open(); try { - // Write characters in UTF-8 encoding fileStream.Charset = "utf-8"; fileStream.WriteText(data); - // If we don't want the BOM, then skip it by setting the starting location to 3 (size of BOM). - // If not, start from position 0, as the BOM will be added automatically when charset==utf8. if (writeByteOrderMark) { fileStream.Position = 0; } @@ -1426,7 +714,7 @@ var ts; fileStream.Position = 3; } fileStream.CopyTo(binaryStream); - binaryStream.SaveToFile(fileName, 2 /*overwrite*/); + binaryStream.SaveToFile(fileName, 2); } finally { binaryStream.Close(); @@ -1504,7 +792,6 @@ var ts; var _path = require("path"); var _os = require('os'); var platform = _os.platform(); - // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive var useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin"; function readFile(fileName, encoding) { if (!_fs.existsSync(fileName)) { @@ -1513,8 +800,6 @@ var ts; var buffer = _fs.readFileSync(fileName); var len = buffer.length; if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) { - // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js, - // flip all byte pairs and treat as little endian. len &= ~1; for (var i = 0; i < len; i += 2) { var temp = buffer[i]; @@ -1524,18 +809,14 @@ var ts; return buffer.toString("utf16le", 2); } if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) { - // Little endian UTF-16 byte order mark detected return buffer.toString("utf16le", 2); } if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { - // UTF-8 byte order mark detected return buffer.toString("utf8", 3); } - // Default is UTF-8 with no byte order mark return buffer.toString("utf8"); } function writeFile(fileName, data, writeByteOrderMark) { - // If a BOM is required, emit one if (writeByteOrderMark) { data = '\uFEFF' + data; } @@ -1572,13 +853,11 @@ var ts; newLine: _os.EOL, useCaseSensitiveFileNames: useCaseSensitiveFileNames, write: function (s) { - // 1 is a standard descriptor for stdout _fs.writeSync(1, s); }, readFile: readFile, writeFile: writeFile, watchFile: function (fileName, callback) { - // watchFile polls a file every 250ms, picking up file notifications. _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged); return { close: function () { _fs.unwatchFile(fileName, fileChanged); } @@ -1630,13 +909,11 @@ var ts; return getNodeSystem(); } else { - return undefined; // Unsupported host + return undefined; } })(); })(ts || (ts = {})); -// /// -/* @internal */ var ts; (function (ts) { ts.Diagnostics = { @@ -2139,6 +1416,9 @@ var ts; Preserve_new_lines_when_emitting_code: { code: 6057, category: ts.DiagnosticCategory.Message, key: "Preserve new-lines when emitting code." }, Specifies_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: { code: 6058, category: ts.DiagnosticCategory.Message, key: "Specifies the root directory of input files. Use to control the output directory structure with --outDir." }, File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: { code: 6059, category: ts.DiagnosticCategory.Error, key: "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files." }, + Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: ts.DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." }, + NEWLINE: { code: 6061, category: ts.DiagnosticCategory.Message, key: "NEWLINE" }, + Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: ts.DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." }, Variable_0_implicitly_has_an_1_type: { code: 7005, category: ts.DiagnosticCategory.Error, key: "Variable '{0}' implicitly has an '{1}' type." }, Parameter_0_implicitly_has_an_1_type: { code: 7006, category: ts.DiagnosticCategory.Error, key: "Parameter '{0}' implicitly has an '{1}' type." }, Member_0_implicitly_has_an_1_type: { code: 7008, category: ts.DiagnosticCategory.Error, key: "Member '{0}' implicitly has an '{1}' type." }, @@ -2185,177 +1465,132 @@ var ts; var ts; (function (ts) { var textToToken = { - "any": 112 /* AnyKeyword */, - "as": 111 /* AsKeyword */, - "boolean": 113 /* BooleanKeyword */, - "break": 66 /* BreakKeyword */, - "case": 67 /* CaseKeyword */, - "catch": 68 /* CatchKeyword */, - "class": 69 /* ClassKeyword */, - "continue": 71 /* ContinueKeyword */, - "const": 70 /* ConstKeyword */, - "constructor": 114 /* ConstructorKeyword */, - "debugger": 72 /* DebuggerKeyword */, - "declare": 115 /* DeclareKeyword */, - "default": 73 /* DefaultKeyword */, - "delete": 74 /* DeleteKeyword */, - "do": 75 /* DoKeyword */, - "else": 76 /* ElseKeyword */, - "enum": 77 /* EnumKeyword */, - "export": 78 /* ExportKeyword */, - "extends": 79 /* ExtendsKeyword */, - "false": 80 /* FalseKeyword */, - "finally": 81 /* FinallyKeyword */, - "for": 82 /* ForKeyword */, - "from": 125 /* FromKeyword */, - "function": 83 /* FunctionKeyword */, - "get": 116 /* GetKeyword */, - "if": 84 /* IfKeyword */, - "implements": 102 /* ImplementsKeyword */, - "import": 85 /* ImportKeyword */, - "in": 86 /* InKeyword */, - "instanceof": 87 /* InstanceOfKeyword */, - "interface": 103 /* InterfaceKeyword */, - "let": 104 /* LetKeyword */, - "module": 117 /* ModuleKeyword */, - "namespace": 118 /* NamespaceKeyword */, - "new": 88 /* NewKeyword */, - "null": 89 /* NullKeyword */, - "number": 120 /* NumberKeyword */, - "package": 105 /* PackageKeyword */, - "private": 106 /* PrivateKeyword */, - "protected": 107 /* ProtectedKeyword */, - "public": 108 /* PublicKeyword */, - "require": 119 /* RequireKeyword */, - "return": 90 /* ReturnKeyword */, - "set": 121 /* SetKeyword */, - "static": 109 /* StaticKeyword */, - "string": 122 /* StringKeyword */, - "super": 91 /* SuperKeyword */, - "switch": 92 /* SwitchKeyword */, - "symbol": 123 /* SymbolKeyword */, - "this": 93 /* ThisKeyword */, - "throw": 94 /* ThrowKeyword */, - "true": 95 /* TrueKeyword */, - "try": 96 /* TryKeyword */, - "type": 124 /* TypeKeyword */, - "typeof": 97 /* TypeOfKeyword */, - "var": 98 /* VarKeyword */, - "void": 99 /* VoidKeyword */, - "while": 100 /* WhileKeyword */, - "with": 101 /* WithKeyword */, - "yield": 110 /* YieldKeyword */, - "of": 126 /* OfKeyword */, - "{": 14 /* OpenBraceToken */, - "}": 15 /* CloseBraceToken */, - "(": 16 /* OpenParenToken */, - ")": 17 /* CloseParenToken */, - "[": 18 /* OpenBracketToken */, - "]": 19 /* CloseBracketToken */, - ".": 20 /* DotToken */, - "...": 21 /* DotDotDotToken */, - ";": 22 /* SemicolonToken */, - ",": 23 /* CommaToken */, - "<": 24 /* LessThanToken */, - ">": 25 /* GreaterThanToken */, - "<=": 26 /* LessThanEqualsToken */, - ">=": 27 /* GreaterThanEqualsToken */, - "==": 28 /* EqualsEqualsToken */, - "!=": 29 /* ExclamationEqualsToken */, - "===": 30 /* EqualsEqualsEqualsToken */, - "!==": 31 /* ExclamationEqualsEqualsToken */, - "=>": 32 /* EqualsGreaterThanToken */, - "+": 33 /* PlusToken */, - "-": 34 /* MinusToken */, - "*": 35 /* AsteriskToken */, - "/": 36 /* SlashToken */, - "%": 37 /* PercentToken */, - "++": 38 /* PlusPlusToken */, - "--": 39 /* MinusMinusToken */, - "<<": 40 /* LessThanLessThanToken */, - ">>": 41 /* GreaterThanGreaterThanToken */, - ">>>": 42 /* GreaterThanGreaterThanGreaterThanToken */, - "&": 43 /* AmpersandToken */, - "|": 44 /* BarToken */, - "^": 45 /* CaretToken */, - "!": 46 /* ExclamationToken */, - "~": 47 /* TildeToken */, - "&&": 48 /* AmpersandAmpersandToken */, - "||": 49 /* BarBarToken */, - "?": 50 /* QuestionToken */, - ":": 51 /* ColonToken */, - "=": 53 /* EqualsToken */, - "+=": 54 /* PlusEqualsToken */, - "-=": 55 /* MinusEqualsToken */, - "*=": 56 /* AsteriskEqualsToken */, - "/=": 57 /* SlashEqualsToken */, - "%=": 58 /* PercentEqualsToken */, - "<<=": 59 /* LessThanLessThanEqualsToken */, - ">>=": 60 /* GreaterThanGreaterThanEqualsToken */, - ">>>=": 61 /* GreaterThanGreaterThanGreaterThanEqualsToken */, - "&=": 62 /* AmpersandEqualsToken */, - "|=": 63 /* BarEqualsToken */, - "^=": 64 /* CaretEqualsToken */, - "@": 52 /* AtToken */ + "any": 112, + "as": 111, + "boolean": 113, + "break": 66, + "case": 67, + "catch": 68, + "class": 69, + "continue": 71, + "const": 70, + "constructor": 114, + "debugger": 72, + "declare": 115, + "default": 73, + "delete": 74, + "do": 75, + "else": 76, + "enum": 77, + "export": 78, + "extends": 79, + "false": 80, + "finally": 81, + "for": 82, + "from": 125, + "function": 83, + "get": 116, + "if": 84, + "implements": 102, + "import": 85, + "in": 86, + "instanceof": 87, + "interface": 103, + "let": 104, + "module": 117, + "namespace": 118, + "new": 88, + "null": 89, + "number": 120, + "package": 105, + "private": 106, + "protected": 107, + "public": 108, + "require": 119, + "return": 90, + "set": 121, + "static": 109, + "string": 122, + "super": 91, + "switch": 92, + "symbol": 123, + "this": 93, + "throw": 94, + "true": 95, + "try": 96, + "type": 124, + "typeof": 97, + "var": 98, + "void": 99, + "while": 100, + "with": 101, + "yield": 110, + "of": 126, + "{": 14, + "}": 15, + "(": 16, + ")": 17, + "[": 18, + "]": 19, + ".": 20, + "...": 21, + ";": 22, + ",": 23, + "<": 24, + ">": 25, + "<=": 26, + ">=": 27, + "==": 28, + "!=": 29, + "===": 30, + "!==": 31, + "=>": 32, + "+": 33, + "-": 34, + "*": 35, + "/": 36, + "%": 37, + "++": 38, + "--": 39, + "<<": 40, + ">>": 41, + ">>>": 42, + "&": 43, + "|": 44, + "^": 45, + "!": 46, + "~": 47, + "&&": 48, + "||": 49, + "?": 50, + ":": 51, + "=": 53, + "+=": 54, + "-=": 55, + "*=": 56, + "/=": 57, + "%=": 58, + "<<=": 59, + ">>=": 60, + ">>>=": 61, + "&=": 62, + "|=": 63, + "^=": 64, + "@": 52 }; - /* - As per ECMAScript Language Specification 3th Edition, Section 7.6: Identifiers - IdentifierStart :: - Can contain Unicode 3.0.0 categories: - Uppercase letter (Lu), - Lowercase letter (Ll), - Titlecase letter (Lt), - Modifier letter (Lm), - Other letter (Lo), or - Letter number (Nl). - IdentifierPart :: = - Can contain IdentifierStart + Unicode 3.0.0 categories: - Non-spacing mark (Mn), - Combining spacing mark (Mc), - Decimal number (Nd), or - Connector punctuation (Pc). - - Codepoint ranges for ES3 Identifiers are extracted from the Unicode 3.0.0 specification at: - http://www.unicode.org/Public/3.0-Update/UnicodeData-3.0.0.txt - */ var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; - /* - As per ECMAScript Language Specification 5th Edition, Section 7.6: ISyntaxToken Names and Identifiers - IdentifierStart :: - Can contain Unicode 6.2 categories: - Uppercase letter (Lu), - Lowercase letter (Ll), - Titlecase letter (Lt), - Modifier letter (Lm), - Other letter (Lo), or - Letter number (Nl). - IdentifierPart :: - Can contain IdentifierStart + Unicode 6.2 categories: - Non-spacing mark (Mn), - Combining spacing mark (Mc), - Decimal number (Nd), - Connector punctuation (Pc), - , or - . - - Codepoint ranges for ES5 Identifiers are extracted from the Unicode 6.2 specification at: - http://www.unicode.org/Public/6.2.0/ucd/UnicodeData.txt - */ var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; function lookupInUnicodeMap(code, map) { - // Bail out quickly if it couldn't possibly be in the map. if (code < map[0]) { return false; } - // Perform binary search in one of the Unicode range maps var lo = 0; var hi = map.length; var mid; while (lo + 1 < hi) { mid = lo + (hi - lo) / 2; - // mid has to be even to catch a range's beginning mid -= mid % 2; if (map[mid] <= code && code <= map[mid + 1]) { return true; @@ -2369,14 +1604,14 @@ var ts; } return false; } - /* @internal */ function isUnicodeIdentifierStart(code, languageVersion) { - return languageVersion >= 1 /* ES5 */ ? + function isUnicodeIdentifierStart(code, languageVersion) { + return languageVersion >= 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierStart) : lookupInUnicodeMap(code, unicodeES3IdentifierStart); } ts.isUnicodeIdentifierStart = isUnicodeIdentifierStart; function isUnicodeIdentifierPart(code, languageVersion) { - return languageVersion >= 1 /* ES5 */ ? + return languageVersion >= 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierPart) : lookupInUnicodeMap(code, unicodeES3IdentifierPart); } @@ -2394,12 +1629,10 @@ var ts; return tokenStrings[t]; } ts.tokenToString = tokenToString; - /* @internal */ function stringToToken(s) { return textToToken[s]; } ts.stringToToken = stringToToken; - /* @internal */ function computeLineStarts(text) { var result = new Array(); var pos = 0; @@ -2407,16 +1640,16 @@ var ts; while (pos < text.length) { var ch = text.charCodeAt(pos++); switch (ch) { - case 13 /* carriageReturn */: - if (text.charCodeAt(pos) === 10 /* lineFeed */) { + case 13: + if (text.charCodeAt(pos) === 10) { pos++; } - case 10 /* lineFeed */: + case 10: result.push(lineStart); lineStart = pos; break; default: - if (ch > 127 /* maxAsciiCharacter */ && isLineBreak(ch)) { + if (ch > 127 && isLineBreak(ch)) { result.push(lineStart); lineStart = pos; } @@ -2431,25 +1664,18 @@ var ts; return computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character); } ts.getPositionOfLineAndCharacter = getPositionOfLineAndCharacter; - /* @internal */ function computePositionOfLineAndCharacter(lineStarts, line, character) { ts.Debug.assert(line >= 0 && line < lineStarts.length); return lineStarts[line] + character; } ts.computePositionOfLineAndCharacter = computePositionOfLineAndCharacter; - /* @internal */ function getLineStarts(sourceFile) { return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text)); } ts.getLineStarts = getLineStarts; - /* @internal */ function computeLineAndCharacterOfPosition(lineStarts, position) { var lineNumber = ts.binarySearch(lineStarts, position); if (lineNumber < 0) { - // If the actual position was not found, - // the binary search returns the negative value of the next line start - // e.g. if the line starts at [5, 10, 23, 80] and the position requested was 20 - // then the search will return -2 lineNumber = ~lineNumber - 1; } return { @@ -2464,20 +1690,18 @@ var ts; ts.getLineAndCharacterOfPosition = getLineAndCharacterOfPosition; var hasOwnProperty = Object.prototype.hasOwnProperty; function isWhiteSpace(ch) { - // Note: nextLine is in the Zs space, and should be considered to be a whitespace. - // It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript. - return ch === 32 /* space */ || - ch === 9 /* tab */ || - ch === 11 /* verticalTab */ || - ch === 12 /* formFeed */ || - ch === 160 /* nonBreakingSpace */ || - ch === 133 /* nextLine */ || - ch === 5760 /* ogham */ || - ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ || - ch === 8239 /* narrowNoBreakSpace */ || - ch === 8287 /* mathematicalSpace */ || - ch === 12288 /* ideographicSpace */ || - ch === 65279 /* byteOrderMark */; + return ch === 32 || + ch === 9 || + ch === 11 || + ch === 12 || + ch === 160 || + ch === 133 || + ch === 5760 || + ch >= 8192 && ch <= 8203 || + ch === 8239 || + ch === 8287 || + ch === 12288 || + ch === 65279; } ts.isWhiteSpace = isWhiteSpace; function isLineBreak(ch) { @@ -2491,43 +1715,41 @@ var ts; // \u2029 Paragraph separator // Only the characters in Table 3 are treated as line terminators. Other new line or line // breaking characters are treated as white space but not as line terminators. - return ch === 10 /* lineFeed */ || - ch === 13 /* carriageReturn */ || - ch === 8232 /* lineSeparator */ || - ch === 8233 /* paragraphSeparator */; + return ch === 10 || + ch === 13 || + ch === 8232 || + ch === 8233; } ts.isLineBreak = isLineBreak; function isDigit(ch) { - return ch >= 48 /* _0 */ && ch <= 57 /* _9 */; + return ch >= 48 && ch <= 57; } - /* @internal */ function isOctalDigit(ch) { - return ch >= 48 /* _0 */ && ch <= 55 /* _7 */; + return ch >= 48 && ch <= 55; } ts.isOctalDigit = isOctalDigit; - /* @internal */ function skipTrivia(text, pos, stopAfterLineBreak) { while (true) { var ch = text.charCodeAt(pos); switch (ch) { - case 13 /* carriageReturn */: - if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) { + case 13: + if (text.charCodeAt(pos + 1) === 10) { pos++; } - case 10 /* lineFeed */: + case 10: pos++; if (stopAfterLineBreak) { return pos; } continue; - case 9 /* tab */: - case 11 /* verticalTab */: - case 12 /* formFeed */: - case 32 /* space */: + case 9: + case 11: + case 12: + case 32: pos++; continue; - case 47 /* slash */: - if (text.charCodeAt(pos + 1) === 47 /* slash */) { + case 47: + if (text.charCodeAt(pos + 1) === 47) { pos += 2; while (pos < text.length) { if (isLineBreak(text.charCodeAt(pos))) { @@ -2537,10 +1759,10 @@ var ts; } continue; } - if (text.charCodeAt(pos + 1) === 42 /* asterisk */) { + if (text.charCodeAt(pos + 1) === 42) { pos += 2; while (pos < text.length) { - if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) { + if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { pos += 2; break; } @@ -2549,16 +1771,16 @@ var ts; continue; } break; - case 60 /* lessThan */: - case 61 /* equals */: - case 62 /* greaterThan */: + case 60: + case 61: + case 62: if (isConflictMarkerTrivia(text, pos)) { pos = scanConflictMarkerTrivia(text, pos); continue; } break; default: - if (ch > 127 /* maxAsciiCharacter */ && (isWhiteSpace(ch) || isLineBreak(ch))) { + if (ch > 127 && (isWhiteSpace(ch) || isLineBreak(ch))) { pos++; continue; } @@ -2568,12 +1790,9 @@ var ts; } } ts.skipTrivia = skipTrivia; - // All conflict markers consist of the same character repeated seven times. If it is - // a <<<<<<< or >>>>>>> marker then it is also followd by a space. var mergeConflictMarkerLength = "<<<<<<<".length; function isConflictMarkerTrivia(text, pos) { ts.Debug.assert(pos >= 0); - // Conflict markers must be at the start of a line. if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) { var ch = text.charCodeAt(pos); if ((pos + mergeConflictMarkerLength) < text.length) { @@ -2582,8 +1801,8 @@ var ts; return false; } } - return ch === 61 /* equals */ || - text.charCodeAt(pos + mergeConflictMarkerLength) === 32 /* space */; + return ch === 61 || + text.charCodeAt(pos + mergeConflictMarkerLength) === 32; } } return false; @@ -2594,18 +1813,16 @@ var ts; } var ch = text.charCodeAt(pos); var len = text.length; - if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) { + if (ch === 60 || ch === 62) { while (pos < len && !isLineBreak(text.charCodeAt(pos))) { pos++; } } else { - ts.Debug.assert(ch === 61 /* equals */); - // Consume everything from the start of the mid-conlict marker to the start of the next - // end-conflict marker. + ts.Debug.assert(ch === 61); while (pos < len) { var ch_1 = text.charCodeAt(pos); - if (ch_1 === 62 /* greaterThan */ && isConflictMarkerTrivia(text, pos)) { + if (ch_1 === 62 && isConflictMarkerTrivia(text, pos)) { break; } pos++; @@ -2613,47 +1830,40 @@ var ts; } return pos; } - // Extract comments from the given source text starting at the given position. If trailing is - // false, whitespace is skipped until the first line break and comments between that location - // and the next token are returned.If trailing is true, comments occurring between the given - // position and the next line break are returned.The return value is an array containing a - // TextRange for each comment. Single-line comment ranges include the beginning '//' characters - // but not the ending line break. Multi - line comment ranges include the beginning '/* and - // ending '*/' characters.The return value is undefined if no comments were found. function getCommentRanges(text, pos, trailing) { var result; var collecting = trailing || pos === 0; while (true) { var ch = text.charCodeAt(pos); switch (ch) { - case 13 /* carriageReturn */: - if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) { + case 13: + if (text.charCodeAt(pos + 1) === 10) { pos++; } - case 10 /* lineFeed */: + case 10: pos++; if (trailing) { return result; } collecting = true; if (result && result.length) { - result[result.length - 1].hasTrailingNewLine = true; + ts.lastOrUndefined(result).hasTrailingNewLine = true; } continue; - case 9 /* tab */: - case 11 /* verticalTab */: - case 12 /* formFeed */: - case 32 /* space */: + case 9: + case 11: + case 12: + case 32: pos++; continue; - case 47 /* slash */: + case 47: var nextChar = text.charCodeAt(pos + 1); var hasTrailingNewLine = false; - if (nextChar === 47 /* slash */ || nextChar === 42 /* asterisk */) { - var kind = nextChar === 47 /* slash */ ? 2 /* SingleLineCommentTrivia */ : 3 /* MultiLineCommentTrivia */; + if (nextChar === 47 || nextChar === 42) { + var kind = nextChar === 47 ? 2 : 3; var startPos = pos; pos += 2; - if (nextChar === 47 /* slash */) { + if (nextChar === 47) { while (pos < text.length) { if (isLineBreak(text.charCodeAt(pos))) { hasTrailingNewLine = true; @@ -2664,7 +1874,7 @@ var ts; } else { while (pos < text.length) { - if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) { + if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { pos += 2; break; } @@ -2681,9 +1891,9 @@ var ts; } break; default: - if (ch > 127 /* maxAsciiCharacter */ && (isWhiteSpace(ch) || isLineBreak(ch))) { + if (ch > 127 && (isWhiteSpace(ch) || isLineBreak(ch))) { if (result && result.length && isLineBreak(ch)) { - result[result.length - 1].hasTrailingNewLine = true; + ts.lastOrUndefined(result).hasTrailingNewLine = true; } pos++; continue; @@ -2702,24 +1912,22 @@ var ts; } ts.getTrailingCommentRanges = getTrailingCommentRanges; function isIdentifierStart(ch, languageVersion) { - return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || - ch === 36 /* $ */ || ch === 95 /* _ */ || - ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion); + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierStart(ch, languageVersion); } ts.isIdentifierStart = isIdentifierStart; function isIdentifierPart(ch, languageVersion) { - return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || - ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || - ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion); + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch >= 48 && ch <= 57 || ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierPart(ch, languageVersion); } ts.isIdentifierPart = isIdentifierPart; - // Creates a scanner over a (possibly unspecified) range of a piece of text. - /* @internal */ function createScanner(languageVersion, skipTrivia, text, onError, start, length) { - var pos; // Current position (end position of text of current token) - var end; // end of text - var startPos; // Start position of whitespace before current token - var tokenPos; // Start position of text of current token + var pos; + var end; + var startPos; + var tokenPos; var token; var tokenValue; var precedingLineBreak; @@ -2735,8 +1943,8 @@ var ts; getTokenValue: function () { return tokenValue; }, hasExtendedUnicodeEscape: function () { return hasExtendedUnicodeEscape; }, hasPrecedingLineBreak: function () { return precedingLineBreak; }, - isIdentifier: function () { return token === 65 /* Identifier */ || token > 101 /* LastReservedWord */; }, - isReservedWord: function () { return token >= 66 /* FirstReservedWord */ && token <= 101 /* LastReservedWord */; }, + isIdentifier: function () { return token === 65 || token > 101; }, + isReservedWord: function () { return token >= 66 && token <= 101; }, isUnterminated: function () { return tokenIsUnterminated; }, reScanGreaterToken: reScanGreaterToken, reScanSlashToken: reScanSlashToken, @@ -2755,28 +1963,28 @@ var ts; } } function isIdentifierStart(ch) { - return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || - ch === 36 /* $ */ || ch === 95 /* _ */ || - ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion); + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierStart(ch, languageVersion); } function isIdentifierPart(ch) { - return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || - ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || - ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion); + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch >= 48 && ch <= 57 || ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierPart(ch, languageVersion); } function scanNumber() { var start = pos; while (isDigit(text.charCodeAt(pos))) pos++; - if (text.charCodeAt(pos) === 46 /* dot */) { + if (text.charCodeAt(pos) === 46) { pos++; while (isDigit(text.charCodeAt(pos))) pos++; } var end = pos; - if (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */) { + if (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101) { pos++; - if (text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) + if (text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) pos++; if (isDigit(text.charCodeAt(pos))) { pos++; @@ -2797,17 +2005,9 @@ var ts; } return +(text.substring(start, pos)); } - /** - * Scans the given number of hexadecimal digits in the text, - * returning -1 if the given number is unavailable. - */ function scanExactNumberOfHexDigits(count) { return scanHexDigits(count, false); } - /** - * Scans as many hexadecimal digits as are available in the text, - * returning -1 if the given number of digits was unavailable. - */ function scanMinimumNumberOfHexDigits(count) { return scanHexDigits(count, true); } @@ -2816,14 +2016,14 @@ var ts; var value = 0; while (digits < minCount || scanAsManyAsPossible) { var ch = text.charCodeAt(pos); - if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) { - value = value * 16 + ch - 48 /* _0 */; + if (ch >= 48 && ch <= 57) { + value = value * 16 + ch - 48; } - else if (ch >= 65 /* A */ && ch <= 70 /* F */) { - value = value * 16 + ch - 65 /* A */ + 10; + else if (ch >= 65 && ch <= 70) { + value = value * 16 + ch - 65 + 10; } - else if (ch >= 97 /* a */ && ch <= 102 /* f */) { - value = value * 16 + ch - 97 /* a */ + 10; + else if (ch >= 97 && ch <= 102) { + value = value * 16 + ch - 97 + 10; } else { break; @@ -2853,7 +2053,7 @@ var ts; pos++; break; } - if (ch === 92 /* backslash */) { + if (ch === 92) { result += text.substring(start, pos); result += scanEscapeSequence(); start = pos; @@ -2869,12 +2069,8 @@ var ts; } return result; } - /** - * Sets the current 'tokenValue' and returns a NoSubstitutionTemplateLiteral or - * a literal component of a TemplateExpression. - */ function scanTemplateAndSetTokenValue() { - var startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */; + var startedWithBacktick = text.charCodeAt(pos) === 96; pos++; var start = pos; var contents = ""; @@ -2884,37 +2080,32 @@ var ts; contents += text.substring(start, pos); tokenIsUnterminated = true; error(ts.Diagnostics.Unterminated_template_literal); - resultingToken = startedWithBacktick ? 10 /* NoSubstitutionTemplateLiteral */ : 13 /* TemplateTail */; + resultingToken = startedWithBacktick ? 10 : 13; break; } var currChar = text.charCodeAt(pos); - // '`' - if (currChar === 96 /* backtick */) { + if (currChar === 96) { contents += text.substring(start, pos); pos++; - resultingToken = startedWithBacktick ? 10 /* NoSubstitutionTemplateLiteral */ : 13 /* TemplateTail */; + resultingToken = startedWithBacktick ? 10 : 13; break; } - // '${' - if (currChar === 36 /* $ */ && pos + 1 < end && text.charCodeAt(pos + 1) === 123 /* openBrace */) { + if (currChar === 36 && pos + 1 < end && text.charCodeAt(pos + 1) === 123) { contents += text.substring(start, pos); pos += 2; - resultingToken = startedWithBacktick ? 11 /* TemplateHead */ : 12 /* TemplateMiddle */; + resultingToken = startedWithBacktick ? 11 : 12; break; } - // Escape character - if (currChar === 92 /* backslash */) { + if (currChar === 92) { contents += text.substring(start, pos); contents += scanEscapeSequence(); start = pos; continue; } - // Speculated ECMAScript 6 Spec 11.8.6.1: - // and LineTerminatorSequences are normalized to for Template Values - if (currChar === 13 /* carriageReturn */) { + if (currChar === 13) { contents += text.substring(start, pos); pos++; - if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) { + if (pos < end && text.charCodeAt(pos) === 10) { pos++; } contents += "\n"; @@ -2935,46 +2126,40 @@ var ts; } var ch = text.charCodeAt(pos++); switch (ch) { - case 48 /* _0 */: + case 48: return "\0"; - case 98 /* b */: + case 98: return "\b"; - case 116 /* t */: + case 116: return "\t"; - case 110 /* n */: + case 110: return "\n"; - case 118 /* v */: + case 118: return "\v"; - case 102 /* f */: + case 102: return "\f"; - case 114 /* r */: + case 114: return "\r"; - case 39 /* singleQuote */: + case 39: return "\'"; - case 34 /* doubleQuote */: + case 34: return "\""; - case 117 /* u */: - // '\u{DDDDDDDD}' - if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) { + case 117: + if (pos < end && text.charCodeAt(pos) === 123) { hasExtendedUnicodeEscape = true; pos++; return scanExtendedUnicodeEscape(); } - // '\uDDDD' return scanHexadecimalEscape(4); - case 120 /* x */: - // '\xDD' + case 120: return scanHexadecimalEscape(2); - // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence), - // the line terminator is interpreted to be "the empty code unit sequence". - case 13 /* carriageReturn */: - if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) { + case 13: + if (pos < end && text.charCodeAt(pos) === 10) { pos++; } - // fall through - case 10 /* lineFeed */: - case 8232 /* lineSeparator */: - case 8233 /* paragraphSeparator */: + case 10: + case 8232: + case 8233: return ""; default: return String.fromCharCode(ch); @@ -2993,7 +2178,6 @@ var ts; function scanExtendedUnicodeEscape() { var escapedValue = scanMinimumNumberOfHexDigits(1); var isInvalidExtendedEscape = false; - // Validate the value of the digit if (escapedValue < 0) { error(ts.Diagnostics.Hexadecimal_digit_expected); isInvalidExtendedEscape = true; @@ -3006,8 +2190,7 @@ var ts; error(ts.Diagnostics.Unexpected_end_of_text); isInvalidExtendedEscape = true; } - else if (text.charCodeAt(pos) == 125 /* closeBrace */) { - // Only swallow the following character up if it's a '}'. + else if (text.charCodeAt(pos) == 125) { pos++; } else { @@ -3019,7 +2202,6 @@ var ts; } return utf16EncodeAsString(escapedValue); } - // Derived from the 10.1.1 UTF16Encoding of the ES6 Spec. function utf16EncodeAsString(codePoint) { ts.Debug.assert(0x0 <= codePoint && codePoint <= 0x10FFFF); if (codePoint <= 65535) { @@ -3029,10 +2211,8 @@ var ts; var codeUnit2 = ((codePoint - 65536) % 1024) + 0xDC00; return String.fromCharCode(codeUnit1, codeUnit2); } - // Current character is known to be a backslash. Check for Unicode escape of the form '\uXXXX' - // and return code point value if valid Unicode escape is found. Otherwise return -1. function peekUnicodeEscape() { - if (pos + 5 < end && text.charCodeAt(pos + 1) === 117 /* u */) { + if (pos + 5 < end && text.charCodeAt(pos + 1) === 117) { var start_1 = pos; pos += 2; var value = scanExactNumberOfHexDigits(4); @@ -3049,14 +2229,13 @@ var ts; if (isIdentifierPart(ch)) { pos++; } - else if (ch === 92 /* backslash */) { + else if (ch === 92) { ch = peekUnicodeEscape(); if (!(ch >= 0 && isIdentifierPart(ch))) { break; } result += text.substring(start, pos); result += String.fromCharCode(ch); - // Valid Unicode escape is always six characters pos += 6; start = pos; } @@ -3068,25 +2247,22 @@ var ts; return result; } function getIdentifierToken() { - // Reserved words are between 2 and 11 characters long and start with a lowercase letter var len = tokenValue.length; if (len >= 2 && len <= 11) { var ch = tokenValue.charCodeAt(0); - if (ch >= 97 /* a */ && ch <= 122 /* z */ && hasOwnProperty.call(textToToken, tokenValue)) { + if (ch >= 97 && ch <= 122 && hasOwnProperty.call(textToToken, tokenValue)) { return token = textToToken[tokenValue]; } } - return token = 65 /* Identifier */; + return token = 65; } function scanBinaryOrOctalDigits(base) { ts.Debug.assert(base !== 2 || base !== 8, "Expected either base 2 or base 8"); var value = 0; - // For counting number of digits; Valid binaryIntegerLiteral must have at least one binary digit following B or b. - // Similarly valid octalIntegerLiteral must have at least one octal digit following o or O. var numberOfDigits = 0; while (true) { var ch = text.charCodeAt(pos); - var valueOfCh = ch - 48 /* _0 */; + var valueOfCh = ch - 48; if (!isDigit(ch) || valueOfCh >= base) { break; } @@ -3094,7 +2270,6 @@ var ts; pos++; numberOfDigits++; } - // Invalid binaryIntegerLiteral or octalIntegerLiteral if (numberOfDigits === 0) { return -1; } @@ -3108,31 +2283,30 @@ var ts; while (true) { tokenPos = pos; if (pos >= end) { - return token = 1 /* EndOfFileToken */; + return token = 1; } var ch = text.charCodeAt(pos); switch (ch) { - case 10 /* lineFeed */: - case 13 /* carriageReturn */: + case 10: + case 13: precedingLineBreak = true; if (skipTrivia) { pos++; continue; } else { - if (ch === 13 /* carriageReturn */ && pos + 1 < end && text.charCodeAt(pos + 1) === 10 /* lineFeed */) { - // consume both CR and LF + if (ch === 13 && pos + 1 < end && text.charCodeAt(pos + 1) === 10) { pos += 2; } else { pos++; } - return token = 4 /* NewLineTrivia */; + return token = 4; } - case 9 /* tab */: - case 11 /* verticalTab */: - case 12 /* formFeed */: - case 32 /* space */: + case 9: + case 11: + case 12: + case 32: if (skipTrivia) { pos++; continue; @@ -3141,74 +2315,73 @@ var ts; while (pos < end && isWhiteSpace(text.charCodeAt(pos))) { pos++; } - return token = 5 /* WhitespaceTrivia */; + return token = 5; } - case 33 /* exclamation */: - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - if (text.charCodeAt(pos + 2) === 61 /* equals */) { - return pos += 3, token = 31 /* ExclamationEqualsEqualsToken */; + case 33: + if (text.charCodeAt(pos + 1) === 61) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 31; } - return pos += 2, token = 29 /* ExclamationEqualsToken */; + return pos += 2, token = 29; } - return pos++, token = 46 /* ExclamationToken */; - case 34 /* doubleQuote */: - case 39 /* singleQuote */: + return pos++, token = 46; + case 34: + case 39: tokenValue = scanString(); - return token = 8 /* StringLiteral */; - case 96 /* backtick */: + return token = 8; + case 96: return token = scanTemplateAndSetTokenValue(); - case 37 /* percent */: - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 58 /* PercentEqualsToken */; - } - return pos++, token = 37 /* PercentToken */; - case 38 /* ampersand */: - if (text.charCodeAt(pos + 1) === 38 /* ampersand */) { - return pos += 2, token = 48 /* AmpersandAmpersandToken */; - } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 62 /* AmpersandEqualsToken */; - } - return pos++, token = 43 /* AmpersandToken */; - case 40 /* openParen */: - return pos++, token = 16 /* OpenParenToken */; - case 41 /* closeParen */: - return pos++, token = 17 /* CloseParenToken */; - case 42 /* asterisk */: - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 56 /* AsteriskEqualsToken */; - } - return pos++, token = 35 /* AsteriskToken */; - case 43 /* plus */: - if (text.charCodeAt(pos + 1) === 43 /* plus */) { - return pos += 2, token = 38 /* PlusPlusToken */; - } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 54 /* PlusEqualsToken */; - } - return pos++, token = 33 /* PlusToken */; - case 44 /* comma */: - return pos++, token = 23 /* CommaToken */; - case 45 /* minus */: - if (text.charCodeAt(pos + 1) === 45 /* minus */) { - return pos += 2, token = 39 /* MinusMinusToken */; - } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 55 /* MinusEqualsToken */; - } - return pos++, token = 34 /* MinusToken */; - case 46 /* dot */: + case 37: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 58; + } + return pos++, token = 37; + case 38: + if (text.charCodeAt(pos + 1) === 38) { + return pos += 2, token = 48; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 62; + } + return pos++, token = 43; + case 40: + return pos++, token = 16; + case 41: + return pos++, token = 17; + case 42: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 56; + } + return pos++, token = 35; + case 43: + if (text.charCodeAt(pos + 1) === 43) { + return pos += 2, token = 38; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 54; + } + return pos++, token = 33; + case 44: + return pos++, token = 23; + case 45: + if (text.charCodeAt(pos + 1) === 45) { + return pos += 2, token = 39; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 55; + } + return pos++, token = 34; + case 46: if (isDigit(text.charCodeAt(pos + 1))) { tokenValue = "" + scanNumber(); - return token = 7 /* NumericLiteral */; + return token = 7; } - if (text.charCodeAt(pos + 1) === 46 /* dot */ && text.charCodeAt(pos + 2) === 46 /* dot */) { - return pos += 3, token = 21 /* DotDotDotToken */; + if (text.charCodeAt(pos + 1) === 46 && text.charCodeAt(pos + 2) === 46) { + return pos += 3, token = 21; } - return pos++, token = 20 /* DotToken */; - case 47 /* slash */: - // Single-line comment - if (text.charCodeAt(pos + 1) === 47 /* slash */) { + return pos++, token = 20; + case 47: + if (text.charCodeAt(pos + 1) === 47) { pos += 2; while (pos < end) { if (isLineBreak(text.charCodeAt(pos))) { @@ -3220,16 +2393,15 @@ var ts; continue; } else { - return token = 2 /* SingleLineCommentTrivia */; + return token = 2; } } - // Multi-line comment - if (text.charCodeAt(pos + 1) === 42 /* asterisk */) { + if (text.charCodeAt(pos + 1) === 42) { pos += 2; var commentClosed = false; while (pos < end) { var ch_2 = text.charCodeAt(pos); - if (ch_2 === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) { + if (ch_2 === 42 && text.charCodeAt(pos + 1) === 47) { pos += 2; commentClosed = true; break; @@ -3247,15 +2419,15 @@ var ts; } else { tokenIsUnterminated = !commentClosed; - return token = 3 /* MultiLineCommentTrivia */; + return token = 3; } } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 57 /* SlashEqualsToken */; + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 57; } - return pos++, token = 36 /* SlashToken */; - case 48 /* _0 */: - if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 /* X */ || text.charCodeAt(pos + 1) === 120 /* x */)) { + return pos++, token = 36; + case 48: + if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 || text.charCodeAt(pos + 1) === 120)) { pos += 2; var value = scanMinimumNumberOfHexDigits(1); if (value < 0) { @@ -3263,9 +2435,9 @@ var ts; value = 0; } tokenValue = "" + value; - return token = 7 /* NumericLiteral */; + return token = 7; } - else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 /* B */ || text.charCodeAt(pos + 1) === 98 /* b */)) { + else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 || text.charCodeAt(pos + 1) === 98)) { pos += 2; var value = scanBinaryOrOctalDigits(2); if (value < 0) { @@ -3273,9 +2445,9 @@ var ts; value = 0; } tokenValue = "" + value; - return token = 7 /* NumericLiteral */; + return token = 7; } - else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 /* O */ || text.charCodeAt(pos + 1) === 111 /* o */)) { + else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 || text.charCodeAt(pos + 1) === 111)) { pos += 2; var value = scanBinaryOrOctalDigits(8); if (value < 0) { @@ -3283,110 +2455,106 @@ var ts; value = 0; } tokenValue = "" + value; - return token = 7 /* NumericLiteral */; + return token = 7; } - // Try to parse as an octal if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) { tokenValue = "" + scanOctalDigits(); - return token = 7 /* NumericLiteral */; - } - // This fall-through is a deviation from the EcmaScript grammar. The grammar says that a leading zero - // can only be followed by an octal digit, a dot, or the end of the number literal. However, we are being - // permissive and allowing decimal digits of the form 08* and 09* (which many browsers also do). - case 49 /* _1 */: - case 50 /* _2 */: - case 51 /* _3 */: - case 52 /* _4 */: - case 53 /* _5 */: - case 54 /* _6 */: - case 55 /* _7 */: - case 56 /* _8 */: - case 57 /* _9 */: + return token = 7; + } + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: tokenValue = "" + scanNumber(); - return token = 7 /* NumericLiteral */; - case 58 /* colon */: - return pos++, token = 51 /* ColonToken */; - case 59 /* semicolon */: - return pos++, token = 22 /* SemicolonToken */; - case 60 /* lessThan */: + return token = 7; + case 58: + return pos++, token = 51; + case 59: + return pos++, token = 22; + case 60: if (isConflictMarkerTrivia(text, pos)) { pos = scanConflictMarkerTrivia(text, pos, error); if (skipTrivia) { continue; } else { - return token = 6 /* ConflictMarkerTrivia */; + return token = 6; } } - if (text.charCodeAt(pos + 1) === 60 /* lessThan */) { - if (text.charCodeAt(pos + 2) === 61 /* equals */) { - return pos += 3, token = 59 /* LessThanLessThanEqualsToken */; + if (text.charCodeAt(pos + 1) === 60) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 59; } - return pos += 2, token = 40 /* LessThanLessThanToken */; + return pos += 2, token = 40; } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 26 /* LessThanEqualsToken */; + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 26; } - return pos++, token = 24 /* LessThanToken */; - case 61 /* equals */: + return pos++, token = 24; + case 61: if (isConflictMarkerTrivia(text, pos)) { pos = scanConflictMarkerTrivia(text, pos, error); if (skipTrivia) { continue; } else { - return token = 6 /* ConflictMarkerTrivia */; + return token = 6; } } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - if (text.charCodeAt(pos + 2) === 61 /* equals */) { - return pos += 3, token = 30 /* EqualsEqualsEqualsToken */; + if (text.charCodeAt(pos + 1) === 61) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 30; } - return pos += 2, token = 28 /* EqualsEqualsToken */; + return pos += 2, token = 28; } - if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) { - return pos += 2, token = 32 /* EqualsGreaterThanToken */; + if (text.charCodeAt(pos + 1) === 62) { + return pos += 2, token = 32; } - return pos++, token = 53 /* EqualsToken */; - case 62 /* greaterThan */: + return pos++, token = 53; + case 62: if (isConflictMarkerTrivia(text, pos)) { pos = scanConflictMarkerTrivia(text, pos, error); if (skipTrivia) { continue; } else { - return token = 6 /* ConflictMarkerTrivia */; - } - } - return pos++, token = 25 /* GreaterThanToken */; - case 63 /* question */: - return pos++, token = 50 /* QuestionToken */; - case 91 /* openBracket */: - return pos++, token = 18 /* OpenBracketToken */; - case 93 /* closeBracket */: - return pos++, token = 19 /* CloseBracketToken */; - case 94 /* caret */: - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 64 /* CaretEqualsToken */; - } - return pos++, token = 45 /* CaretToken */; - case 123 /* openBrace */: - return pos++, token = 14 /* OpenBraceToken */; - case 124 /* bar */: - if (text.charCodeAt(pos + 1) === 124 /* bar */) { - return pos += 2, token = 49 /* BarBarToken */; - } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 63 /* BarEqualsToken */; - } - return pos++, token = 44 /* BarToken */; - case 125 /* closeBrace */: - return pos++, token = 15 /* CloseBraceToken */; - case 126 /* tilde */: - return pos++, token = 47 /* TildeToken */; - case 64 /* at */: - return pos++, token = 52 /* AtToken */; - case 92 /* backslash */: + return token = 6; + } + } + return pos++, token = 25; + case 63: + return pos++, token = 50; + case 91: + return pos++, token = 18; + case 93: + return pos++, token = 19; + case 94: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 64; + } + return pos++, token = 45; + case 123: + return pos++, token = 14; + case 124: + if (text.charCodeAt(pos + 1) === 124) { + return pos += 2, token = 49; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 63; + } + return pos++, token = 44; + case 125: + return pos++, token = 15; + case 126: + return pos++, token = 47; + case 64: + return pos++, token = 52; + case 92: var cookedChar = peekUnicodeEscape(); if (cookedChar >= 0 && isIdentifierStart(cookedChar)) { pos += 6; @@ -3394,14 +2562,14 @@ var ts; return token = getIdentifierToken(); } error(ts.Diagnostics.Invalid_character); - return pos++, token = 0 /* Unknown */; + return pos++, token = 0; default: if (isIdentifierStart(ch)) { pos++; while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos))) pos++; tokenValue = text.substring(tokenPos, pos); - if (ch === 92 /* backslash */) { + if (ch === 92) { tokenValue += scanIdentifierParts(); } return token = getIdentifierToken(); @@ -3416,38 +2584,36 @@ var ts; continue; } error(ts.Diagnostics.Invalid_character); - return pos++, token = 0 /* Unknown */; + return pos++, token = 0; } } } function reScanGreaterToken() { - if (token === 25 /* GreaterThanToken */) { - if (text.charCodeAt(pos) === 62 /* greaterThan */) { - if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) { - if (text.charCodeAt(pos + 2) === 61 /* equals */) { - return pos += 3, token = 61 /* GreaterThanGreaterThanGreaterThanEqualsToken */; + if (token === 25) { + if (text.charCodeAt(pos) === 62) { + if (text.charCodeAt(pos + 1) === 62) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 61; } - return pos += 2, token = 42 /* GreaterThanGreaterThanGreaterThanToken */; + return pos += 2, token = 42; } - if (text.charCodeAt(pos + 1) === 61 /* equals */) { - return pos += 2, token = 60 /* GreaterThanGreaterThanEqualsToken */; + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 60; } - return pos++, token = 41 /* GreaterThanGreaterThanToken */; + return pos++, token = 41; } - if (text.charCodeAt(pos) === 61 /* equals */) { - return pos++, token = 27 /* GreaterThanEqualsToken */; + if (text.charCodeAt(pos) === 61) { + return pos++, token = 27; } } return token; } function reScanSlashToken() { - if (token === 36 /* SlashToken */ || token === 57 /* SlashEqualsToken */) { + if (token === 36 || token === 57) { var p = tokenPos + 1; var inEscape = false; var inCharacterClass = false; while (true) { - // If we reach the end of a file, or hit a newline, then this is an unterminated - // regex. Report error and return what we have so far. if (p >= end) { tokenIsUnterminated = true; error(ts.Diagnostics.Unterminated_regular_expression_literal); @@ -3460,23 +2626,19 @@ var ts; break; } if (inEscape) { - // Parsing an escape character; - // reset the flag and just advance to the next char. inEscape = false; } - else if (ch === 47 /* slash */ && !inCharacterClass) { - // A slash within a character class is permissible, - // but in general it signals the end of the regexp literal. + else if (ch === 47 && !inCharacterClass) { p++; break; } - else if (ch === 91 /* openBracket */) { + else if (ch === 91) { inCharacterClass = true; } - else if (ch === 92 /* backslash */) { + else if (ch === 92) { inEscape = true; } - else if (ch === 93 /* closeBracket */) { + else if (ch === 93) { inCharacterClass = false; } p++; @@ -3486,15 +2648,12 @@ var ts; } pos = p; tokenValue = text.substring(tokenPos, pos); - token = 9 /* RegularExpressionLiteral */; + token = 9; } return token; } - /** - * Unconditionally back up and scan a template expression portion. - */ function reScanTemplateToken() { - ts.Debug.assert(token === 15 /* CloseBraceToken */, "'reScanTemplateToken' should only be called on a '}'"); + ts.Debug.assert(token === 15, "'reScanTemplateToken' should only be called on a '}'"); pos = tokenPos; return token = scanTemplateAndSetTokenValue(); } @@ -3506,8 +2665,6 @@ var ts; var saveTokenValue = tokenValue; var savePrecedingLineBreak = precedingLineBreak; var result = callback(); - // If our callback returned something 'falsy' or we're just looking ahead, - // then unconditionally restore us to where we were. if (!result || isLookahead) { pos = savePos; startPos = saveStartPos; @@ -3540,7 +2697,7 @@ var ts; pos = textPos; startPos = textPos; tokenPos = textPos; - token = 0 /* Unknown */; + token = 0; precedingLineBreak = false; tokenValue = undefined; hasExtendedUnicodeEscape = false; @@ -3555,7 +2712,6 @@ var ts; /// var ts; (function (ts) { - /* @internal */ ts.optionDeclarations = [ { name: "charset", @@ -3608,15 +2764,25 @@ var ts; name: "module", shortName: "m", type: { - "commonjs": 1 /* CommonJS */, - "amd": 2 /* AMD */, - "system": 4 /* System */, - "umd": 3 /* UMD */ + "commonjs": 1, + "amd": 2, + "system": 4, + "umd": 3 }, description: ts.Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_or_umd, paramType: ts.Diagnostics.KIND, error: ts.Diagnostics.Argument_for_module_option_must_be_commonjs_amd_system_or_umd }, + { + name: "newLine", + type: { + "crlf": 0, + "lf": 1 + }, + description: ts.Diagnostics.Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix, + paramType: ts.Diagnostics.NEWLINE, + error: ts.Diagnostics.Argument_for_newLine_option_must_be_CRLF_or_LF + }, { name: "noEmit", type: "boolean", @@ -3712,7 +2878,7 @@ var ts; { name: "target", shortName: "t", - type: { "es3": 0 /* ES3 */, "es5": 1 /* ES5 */, "es6": 2 /* ES6 */ }, + type: { "es3": 0, "es5": 1, "es6": 2 }, description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental, paramType: ts.Diagnostics.VERSION, error: ts.Diagnostics.Argument_for_target_option_must_be_ES3_ES5_or_ES6 @@ -3757,18 +2923,16 @@ var ts; var i = 0; while (i < args.length) { var s = args[i++]; - if (s.charCodeAt(0) === 64 /* at */) { + if (s.charCodeAt(0) === 64) { parseResponseFile(s.slice(1)); } - else if (s.charCodeAt(0) === 45 /* minus */) { - s = s.slice(s.charCodeAt(1) === 45 /* minus */ ? 2 : 1).toLowerCase(); - // Try to translate short option names to their full equivalents. + else if (s.charCodeAt(0) === 45) { + s = s.slice(s.charCodeAt(1) === 45 ? 2 : 1).toLowerCase(); if (ts.hasProperty(shortOptionNames, s)) { s = shortOptionNames[s]; } if (ts.hasProperty(optionNameMap, s)) { var opt = optionNameMap[s]; - // Check to see if no argument was provided (e.g. "--locale" is the last command-line argument). if (!args[i] && opt.type !== "boolean") { errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_expects_an_argument, opt.name)); } @@ -3782,7 +2946,6 @@ var ts; case "string": options[opt.name] = args[i++] || ""; break; - // If not a primitive, the possible types are specified in what is effectively a map of options. default: var map = opt.type; var key = (args[i++] || "").toLowerCase(); @@ -3812,14 +2975,14 @@ var ts; var args = []; var pos = 0; while (true) { - while (pos < text.length && text.charCodeAt(pos) <= 32 /* space */) + while (pos < text.length && text.charCodeAt(pos) <= 32) pos++; if (pos >= text.length) break; var start = pos; - if (text.charCodeAt(start) === 34 /* doubleQuote */) { + if (text.charCodeAt(start) === 34) { pos++; - while (pos < text.length && text.charCodeAt(pos) !== 34 /* doubleQuote */) + while (pos < text.length && text.charCodeAt(pos) !== 34) pos++; if (pos < text.length) { args.push(text.substring(start + 1, pos)); @@ -3830,7 +2993,7 @@ var ts; } } else { - while (text.charCodeAt(pos) > 32 /* space */) + while (text.charCodeAt(pos) > 32) pos++; args.push(text.substring(start, pos)); } @@ -3839,10 +3002,6 @@ var ts; } } ts.parseCommandLine = parseCommandLine; - /** - * Read tsconfig.json file - * @param fileName The path to the config file - */ function readConfigFile(fileName) { try { var text = ts.sys.readFile(fileName); @@ -3853,11 +3012,6 @@ var ts; return parseConfigFileText(fileName, text); } ts.readConfigFile = readConfigFile; - /** - * Parse the text of the tsconfig.json file - * @param fileName The path to the config file - * @param jsonText The text of the config file - */ function parseConfigFileText(fileName, jsonText) { try { return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} }; @@ -3867,12 +3021,6 @@ var ts; } } ts.parseConfigFileText = parseConfigFileText; - /** - * Parse the contents of a config file (tsconfig.json). - * @param json The contents of the config file to parse - * @param basePath A root directory to resolve relative path entries in the config - * file to. e.g. outDir - */ function parseConfigFile(json, host, basePath) { var errors = []; return { @@ -3943,7 +3091,6 @@ var ts; ts.parseConfigFile = parseConfigFile; })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { function getDeclarationOfKind(symbol, kind) { @@ -3957,7 +3104,6 @@ var ts; return undefined; } ts.getDeclarationOfKind = getDeclarationOfKind; - // Pool writers to avoid needing to allocate them for every symbol we write. var stringWriters = []; function getSingleLineStringWriter() { if (stringWriters.length == 0) { @@ -3972,8 +3118,6 @@ var ts; writeStringLiteral: writeText, writeParameter: writeText, writeSymbol: writeText, - // Completely ignore indentation for string writers. And map newlines to - // a single space. writeLine: function () { return str += " "; }, increaseIndent: function () { }, decreaseIndent: function () { }, @@ -3993,31 +3137,23 @@ var ts; return node.end - node.pos; } ts.getFullWidth = getFullWidth; - // Returns true if this node contains a parse error anywhere underneath it. function containsParseError(node) { aggregateChildData(node); - return (node.parserContextFlags & 64 /* ThisNodeOrAnySubNodesHasError */) !== 0; + return (node.parserContextFlags & 64) !== 0; } ts.containsParseError = containsParseError; function aggregateChildData(node) { - if (!(node.parserContextFlags & 128 /* HasAggregatedChildData */)) { - // A node is considered to contain a parse error if: - // a) the parser explicitly marked that it had an error - // b) any of it's children reported that it had an error. - var thisNodeOrAnySubNodesHasError = ((node.parserContextFlags & 32 /* ThisNodeHasError */) !== 0) || + if (!(node.parserContextFlags & 128)) { + var thisNodeOrAnySubNodesHasError = ((node.parserContextFlags & 32) !== 0) || ts.forEachChild(node, containsParseError); - // If so, mark ourselves accordingly. if (thisNodeOrAnySubNodesHasError) { - node.parserContextFlags |= 64 /* ThisNodeOrAnySubNodesHasError */; + node.parserContextFlags |= 64; } - // Also mark that we've propogated the child information to this node. This way we can - // always consult the bit directly on this node without needing to check its children - // again. - node.parserContextFlags |= 128 /* HasAggregatedChildData */; + node.parserContextFlags |= 128; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 228 /* SourceFile */) { + while (node && node.kind !== 228) { node = node.parent; } return node; @@ -4028,7 +3164,6 @@ var ts; return ts.getLineStarts(sourceFile)[line]; } ts.getStartPositionOfLine = getStartPositionOfLine; - // This is a useful function for debugging purposes. function nodePosToString(node) { var file = getSourceFileOfNode(node); var loc = ts.getLineAndCharacterOfPosition(file, node.pos); @@ -4039,23 +3174,11 @@ var ts; return node.pos; } ts.getStartPosOfNode = getStartPosOfNode; - // Returns true if this node is missing from the actual source code. 'missing' is different - // from 'undefined/defined'. When a node is undefined (which can happen for optional nodes - // in the tree), it is definitel missing. HOwever, a node may be defined, but still be - // missing. This happens whenever the parser knows it needs to parse something, but can't - // get anything in the source code that it expects at that location. For example: - // - // let a: ; - // - // Here, the Type in the Type-Annotation is not-optional (as there is a colon in the source - // code). So the parser will attempt to parse out a type, and will create an actual node. - // However, this node will be 'missing' in the sense that no actual source-code/tokens are - // contained within it. function nodeIsMissing(node) { if (!node) { return true; } - return node.pos === node.end && node.kind !== 1 /* EndOfFileToken */; + return node.pos === node.end && node.kind !== 1; } ts.nodeIsMissing = nodeIsMissing; function nodeIsPresent(node) { @@ -4063,8 +3186,6 @@ var ts; } ts.nodeIsPresent = nodeIsPresent; function getTokenPosOfNode(node, sourceFile) { - // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't* - // want to skip trivia because this will launch us forward to the next token. if (nodeIsMissing(node)) { return node.pos; } @@ -4097,29 +3218,23 @@ var ts; return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node); } ts.getTextOfNode = getTextOfNode; - // Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' function escapeIdentifier(identifier) { - return identifier.length >= 2 && identifier.charCodeAt(0) === 95 /* _ */ && identifier.charCodeAt(1) === 95 /* _ */ ? "_" + identifier : identifier; + return identifier.length >= 2 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier; } ts.escapeIdentifier = escapeIdentifier; - // Remove extra underscore from escaped identifier function unescapeIdentifier(identifier) { - return identifier.length >= 3 && identifier.charCodeAt(0) === 95 /* _ */ && identifier.charCodeAt(1) === 95 /* _ */ && identifier.charCodeAt(2) === 95 /* _ */ ? identifier.substr(1) : identifier; + return identifier.length >= 3 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 && identifier.charCodeAt(2) === 95 ? identifier.substr(1) : identifier; } ts.unescapeIdentifier = unescapeIdentifier; - // Make an identifier from an external module name by extracting the string after the last "/" and replacing - // all non-alphanumeric characters with underscores function makeIdentifierFromModuleName(moduleName) { return ts.getBaseFileName(moduleName).replace(/\W/g, "_"); } ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName; function isBlockOrCatchScoped(declaration) { - return (getCombinedNodeFlags(declaration) & 12288 /* BlockScoped */) !== 0 || + return (getCombinedNodeFlags(declaration) & 12288) !== 0 || isCatchClauseVariableDeclaration(declaration); } ts.isBlockOrCatchScoped = isBlockOrCatchScoped; - // Gets the nearest enclosing block scope container that has the provided node - // as a descendant, that is not the provided node. function getEnclosingBlockScopeContainer(node) { var current = node.parent; while (current) { @@ -4127,17 +3242,15 @@ var ts; return current; } switch (current.kind) { - case 228 /* SourceFile */: - case 208 /* CaseBlock */: - case 224 /* CatchClause */: - case 206 /* ModuleDeclaration */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 228: + case 208: + case 224: + case 206: + case 187: + case 188: + case 189: return current; - case 180 /* Block */: - // function block is not considered block-scope container - // see comment in binder.ts: bind(...), case for SyntaxKind.Block + case 180: if (!isFunctionLike(current.parent)) { return current; } @@ -4148,14 +3261,11 @@ var ts; ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; function isCatchClauseVariableDeclaration(declaration) { return declaration && - declaration.kind === 199 /* VariableDeclaration */ && + declaration.kind === 199 && declaration.parent && - declaration.parent.kind === 224 /* CatchClause */; + declaration.parent.kind === 224; } ts.isCatchClauseVariableDeclaration = isCatchClauseVariableDeclaration; - // Return display name of an identifier - // Computed property names will just be emitted as "[]", where is the source - // text of the expression in the computed property. function declarationNameToString(name) { return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); } @@ -4189,31 +3299,26 @@ var ts; function getErrorSpanForNode(sourceFile, node) { var errorNode = node; switch (node.kind) { - case 228 /* SourceFile */: + case 228: var pos_1 = ts.skipTrivia(sourceFile.text, 0, false); if (pos_1 === sourceFile.text.length) { - // file is empty - return span for the beginning of the file return ts.createTextSpan(0, 0); } return getSpanOfTokenAtPosition(sourceFile, pos_1); - // This list is a work in progress. Add missing node kinds to improve their error - // spans. - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: + case 199: + case 153: + case 202: + case 175: + case 203: + case 206: + case 205: + case 227: + case 201: + case 163: errorNode = node.name; break; } if (errorNode === undefined) { - // If we don't have a better node, then just set the error on the first token of - // construct. return getSpanOfTokenAtPosition(sourceFile, node.pos); } var pos = nodeIsMissing(errorNode) @@ -4227,61 +3332,49 @@ var ts; } ts.isExternalModule = isExternalModule; function isDeclarationFile(file) { - return (file.flags & 2048 /* DeclarationFile */) !== 0; + return (file.flags & 2048) !== 0; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 205 /* EnumDeclaration */ && isConst(node); + return node.kind === 205 && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 153 /* BindingElement */ || isBindingPattern(node))) { + while (node && (node.kind === 153 || isBindingPattern(node))) { node = node.parent; } return node; } - // Returns the node flags for this node and all relevant parent nodes. This is done so that - // nodes like variable declarations and binding elements can returned a view of their flags - // that includes the modifiers from their container. i.e. flags like export/declare aren't - // stored on the variable declaration directly, but on the containing variable statement - // (if it has one). Similarly, flags for let/const are store on the variable declaration - // list. By calling this function, all those flags are combined so that the client can treat - // the node as if it actually had those flags. function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 199 /* VariableDeclaration */) { + if (node.kind === 199) { node = node.parent; } - if (node && node.kind === 200 /* VariableDeclarationList */) { + if (node && node.kind === 200) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 181 /* VariableStatement */) { + if (node && node.kind === 181) { flags |= node.flags; } return flags; } ts.getCombinedNodeFlags = getCombinedNodeFlags; function isConst(node) { - return !!(getCombinedNodeFlags(node) & 8192 /* Const */); + return !!(getCombinedNodeFlags(node) & 8192); } ts.isConst = isConst; function isLet(node) { - return !!(getCombinedNodeFlags(node) & 4096 /* Let */); + return !!(getCombinedNodeFlags(node) & 4096); } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 183 /* ExpressionStatement */ && node.expression.kind === 8 /* StringLiteral */; + return node.kind === 183 && node.expression.kind === 8; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { - // If parameter/type parameter, the prev token trailing comments are part of this node too - if (node.kind === 130 /* Parameter */ || node.kind === 129 /* TypeParameter */) { - // e.g. (/** blah */ a, /** blah */ b); - // e.g.: ( - // /** blah */ a, - // /** blah */ b); + if (node.kind === 130 || node.kind === 129) { return ts.concatenate(ts.getTrailingCommentRanges(sourceFileOfNode.text, node.pos), ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); } else { @@ -4292,37 +3385,34 @@ var ts; function getJsDocComments(node, sourceFileOfNode) { return ts.filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), isJsDocComment); function isJsDocComment(comment) { - // True if the comment starts with '/**' but not if it is '/**/' - return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ && - sourceFileOfNode.text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ && - sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== 47 /* slash */; + return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === 42 && + sourceFileOfNode.text.charCodeAt(comment.pos + 2) === 42 && + sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== 47; } } ts.getJsDocComments = getJsDocComments; ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; - // Warning: This has the same semantics as the forEach family of functions, - // in that traversal terminates in the event that 'visitor' supplies a truthy value. function forEachReturnStatement(body, visitor) { return traverse(body); function traverse(node) { switch (node.kind) { - case 192 /* ReturnStatement */: + case 192: return visitor(node); - case 208 /* CaseBlock */: - case 180 /* Block */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: + case 208: + case 180: + case 184: + case 185: + case 186: + case 187: + case 188: + case 189: + case 193: + case 194: + case 221: + case 222: + case 195: + case 197: + case 224: return ts.forEachChild(node, traverse); } } @@ -4331,14 +3421,14 @@ var ts; function isVariableLike(node) { if (node) { switch (node.kind) { - case 153 /* BindingElement */: - case 227 /* EnumMember */: - case 130 /* Parameter */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 226 /* ShorthandPropertyAssignment */: - case 199 /* VariableDeclaration */: + case 153: + case 227: + case 130: + case 225: + case 133: + case 132: + case 226: + case 199: return true; } } @@ -4348,8 +3438,8 @@ var ts; function isAccessor(node) { if (node) { switch (node.kind) { - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 137: + case 138: return true; } } @@ -4359,22 +3449,22 @@ var ts; function isFunctionLike(node) { if (node) { switch (node.kind) { - case 136 /* Constructor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 201 /* FunctionDeclaration */: + case 136: + case 163: + case 201: + case 164: + case 135: + case 134: + case 137: + case 138: + case 139: + case 140: + case 141: + case 143: + case 144: + case 163: + case 164: + case 201: return true; } } @@ -4382,11 +3472,11 @@ var ts; } ts.isFunctionLike = isFunctionLike; function isFunctionBlock(node) { - return node && node.kind === 180 /* Block */ && isFunctionLike(node.parent); + return node && node.kind === 180 && isFunctionLike(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 135 /* MethodDeclaration */ && node.parent.kind === 155 /* ObjectLiteralExpression */; + return node && node.kind === 135 && node.parent.kind === 155; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -4405,51 +3495,36 @@ var ts; return undefined; } switch (node.kind) { - case 128 /* ComputedPropertyName */: - // If the grandparent node is an object literal (as opposed to a class), - // then the computed property is not a 'this' container. - // A computed property name in a class needs to be a this container - // so that we can error on it. - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + case 128: + if (node.parent.parent.kind === 202) { return node; } - // If this is a computed property, then the parent should not - // make it a this container. The parent might be a property - // in an object literal, like a method or accessor. But in order for - // such a parent to be a this container, the reference must be in - // the *body* of the container. node = node.parent; break; - case 131 /* Decorator */: - // Decorators are always applied outside of the body of a class or method. - if (node.parent.kind === 130 /* Parameter */ && isClassElement(node.parent.parent)) { - // If the decorator's parent is a Parameter, we resolve the this container from - // the grandparent class declaration. + case 131: + if (node.parent.kind === 130 && isClassElement(node.parent.parent)) { node = node.parent.parent; } else if (isClassElement(node.parent)) { - // If the decorator's parent is a class element, we resolve the 'this' container - // from the parent class declaration. node = node.parent; } break; - case 164 /* ArrowFunction */: + case 164: if (!includeArrowFunctions) { continue; } - // Fall through - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 206 /* ModuleDeclaration */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 205 /* EnumDeclaration */: - case 228 /* SourceFile */: + case 201: + case 163: + case 206: + case 133: + case 132: + case 135: + case 134: + case 136: + case 137: + case 138: + case 205: + case 228: return node; } } @@ -4461,100 +3536,81 @@ var ts; if (!node) return node; switch (node.kind) { - case 128 /* ComputedPropertyName */: - // If the grandparent node is an object literal (as opposed to a class), - // then the computed property is not a 'super' container. - // A computed property name in a class needs to be a super container - // so that we can error on it. - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + case 128: + if (node.parent.parent.kind === 202) { return node; } - // If this is a computed property, then the parent should not - // make it a super container. The parent might be a property - // in an object literal, like a method or accessor. But in order for - // such a parent to be a super container, the reference must be in - // the *body* of the container. node = node.parent; break; - case 131 /* Decorator */: - // Decorators are always applied outside of the body of a class or method. - if (node.parent.kind === 130 /* Parameter */ && isClassElement(node.parent.parent)) { - // If the decorator's parent is a Parameter, we resolve the this container from - // the grandparent class declaration. + case 131: + if (node.parent.kind === 130 && isClassElement(node.parent.parent)) { node = node.parent.parent; } else if (isClassElement(node.parent)) { - // If the decorator's parent is a class element, we resolve the 'this' container - // from the parent class declaration. node = node.parent; } break; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 201: + case 163: + case 164: if (!includeFunctions) { continue; } - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 133: + case 132: + case 135: + case 134: + case 136: + case 137: + case 138: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 160) { return node.tag; } - // Will either be a CallExpression or NewExpression. return node.expression; } ts.getInvokedExpression = getInvokedExpression; function nodeCanBeDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: - // classes are valid targets + case 202: return true; - case 133 /* PropertyDeclaration */: - // property declarations are valid if their parent is a class declaration. - return node.parent.kind === 202 /* ClassDeclaration */; - case 130 /* Parameter */: - // if the parameter's parent has a body and its grandparent is a class declaration, this is a valid target; - return node.parent.body && node.parent.parent.kind === 202 /* ClassDeclaration */; - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 135 /* MethodDeclaration */: - // if this method has a body and its parent is a class declaration, this is a valid target. - return node.body && node.parent.kind === 202 /* ClassDeclaration */; + case 133: + return node.parent.kind === 202; + case 130: + return node.parent.body && node.parent.parent.kind === 202; + case 137: + case 138: + case 135: + return node.body && node.parent.kind === 202; } return false; } ts.nodeCanBeDecorated = nodeCanBeDecorated; function nodeIsDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 202: if (node.decorators) { return true; } return false; - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 133: + case 130: if (node.decorators) { return true; } return false; - case 137 /* GetAccessor */: + case 137: if (node.body && node.decorators) { return true; } return false; - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 135: + case 138: if (node.body && node.decorators) { return true; } @@ -4565,10 +3621,10 @@ var ts; ts.nodeIsDecorated = nodeIsDecorated; function childIsDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 202: return ts.forEach(node.members, nodeOrChildIsDecorated); - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 135: + case 138: return ts.forEach(node.parameters, nodeIsDecorated); } return false; @@ -4580,86 +3636,85 @@ var ts; ts.nodeOrChildIsDecorated = nodeOrChildIsDecorated; function isExpression(node) { switch (node.kind) { - case 93 /* ThisKeyword */: - case 91 /* SuperKeyword */: - case 89 /* NullKeyword */: - case 95 /* TrueKeyword */: - case 80 /* FalseKeyword */: - case 9 /* RegularExpressionLiteral */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 160 /* TaggedTemplateExpression */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 163 /* FunctionExpression */: - case 175 /* ClassExpression */: - case 164 /* ArrowFunction */: - case 167 /* VoidExpression */: - case 165 /* DeleteExpression */: - case 166 /* TypeOfExpression */: - case 168 /* PrefixUnaryExpression */: - case 169 /* PostfixUnaryExpression */: - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 172 /* TemplateExpression */: - case 10 /* NoSubstitutionTemplateLiteral */: - case 176 /* OmittedExpression */: + case 93: + case 91: + case 89: + case 95: + case 80: + case 9: + case 154: + case 155: + case 156: + case 157: + case 158: + case 159: + case 160: + case 161: + case 162: + case 163: + case 175: + case 164: + case 167: + case 165: + case 166: + case 168: + case 169: + case 170: + case 171: + case 174: + case 172: + case 10: + case 176: return true; - case 127 /* QualifiedName */: - while (node.parent.kind === 127 /* QualifiedName */) { + case 127: + while (node.parent.kind === 127) { node = node.parent; } - return node.parent.kind === 145 /* TypeQuery */; - case 65 /* Identifier */: - if (node.parent.kind === 145 /* TypeQuery */) { + return node.parent.kind === 145; + case 65: + if (node.parent.kind === 145) { return true; } - // fall through - case 7 /* NumericLiteral */: - case 8 /* StringLiteral */: + case 7: + case 8: var parent_1 = node.parent; switch (parent_1.kind) { - case 199 /* VariableDeclaration */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 227 /* EnumMember */: - case 225 /* PropertyAssignment */: - case 153 /* BindingElement */: + case 199: + case 130: + case 133: + case 132: + case 227: + case 225: + case 153: return parent_1.initializer === node; - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 192 /* ReturnStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 196 /* ThrowStatement */: - case 194 /* SwitchStatement */: + case 183: + case 184: + case 185: + case 186: + case 192: + case 193: + case 194: + case 221: + case 196: + case 194: return parent_1.expression === node; - case 187 /* ForStatement */: + case 187: var forStatement = parent_1; - return (forStatement.initializer === node && forStatement.initializer.kind !== 200 /* VariableDeclarationList */) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 200) || forStatement.condition === node || forStatement.incrementor === node; - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 188: + case 189: var forInStatement = parent_1; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 200 /* VariableDeclarationList */) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 200) || forInStatement.expression === node; - case 161 /* TypeAssertionExpression */: + case 161: return node === parent_1.expression; - case 178 /* TemplateSpan */: + case 178: return node === parent_1.expression; - case 128 /* ComputedPropertyName */: + case 128: return node === parent_1.expression; - case 131 /* Decorator */: + case 131: return true; default: if (isExpression(parent_1)) { @@ -4672,12 +3727,12 @@ var ts; ts.isExpression = isExpression; function isInstantiatedModule(node, preserveConstEnums) { var moduleState = ts.getModuleInstanceState(node); - return moduleState === 1 /* Instantiated */ || - (preserveConstEnums && moduleState === 2 /* ConstEnumOnly */); + return moduleState === 1 || + (preserveConstEnums && moduleState === 2); } ts.isInstantiatedModule = isInstantiatedModule; function isExternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 220 /* ExternalModuleReference */; + return node.kind === 209 && node.moduleReference.kind === 220; } ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; function getExternalModuleImportEqualsDeclarationExpression(node) { @@ -4686,40 +3741,40 @@ var ts; } ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; function isInternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 220 /* ExternalModuleReference */; + return node.kind === 209 && node.moduleReference.kind !== 220; } ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; function getExternalModuleName(node) { - if (node.kind === 210 /* ImportDeclaration */) { + if (node.kind === 210) { return node.moduleSpecifier; } - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 209) { var reference = node.moduleReference; - if (reference.kind === 220 /* ExternalModuleReference */) { + if (reference.kind === 220) { return reference.expression; } } - if (node.kind === 216 /* ExportDeclaration */) { + if (node.kind === 216) { return node.moduleSpecifier; } } ts.getExternalModuleName = getExternalModuleName; function hasDotDotDotToken(node) { - return node && node.kind === 130 /* Parameter */ && node.dotDotDotToken !== undefined; + return node && node.kind === 130 && node.dotDotDotToken !== undefined; } ts.hasDotDotDotToken = hasDotDotDotToken; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 130 /* Parameter */: + case 130: return node.questionToken !== undefined; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: return node.questionToken !== undefined; - case 226 /* ShorthandPropertyAssignment */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 226: + case 225: + case 133: + case 132: return node.questionToken !== undefined; } } @@ -4727,28 +3782,28 @@ var ts; } ts.hasQuestionToken = hasQuestionToken; function hasRestParameters(s) { - return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined; + return s.parameters.length > 0 && ts.lastOrUndefined(s.parameters).dotDotDotToken !== undefined; } ts.hasRestParameters = hasRestParameters; function isLiteralKind(kind) { - return 7 /* FirstLiteralToken */ <= kind && kind <= 10 /* LastLiteralToken */; + return 7 <= kind && kind <= 10; } ts.isLiteralKind = isLiteralKind; function isTextualLiteralKind(kind) { - return kind === 8 /* StringLiteral */ || kind === 10 /* NoSubstitutionTemplateLiteral */; + return kind === 8 || kind === 10; } ts.isTextualLiteralKind = isTextualLiteralKind; function isTemplateLiteralKind(kind) { - return 10 /* FirstTemplateToken */ <= kind && kind <= 13 /* LastTemplateToken */; + return 10 <= kind && kind <= 13; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return !!node && (node.kind === 152 /* ArrayBindingPattern */ || node.kind === 151 /* ObjectBindingPattern */); + return !!node && (node.kind === 152 || node.kind === 151); } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { while (node) { - if (node.flags & (2 /* Ambient */ | 2048 /* DeclarationFile */)) { + if (node.flags & (2 | 2048)) { return true; } node = node.parent; @@ -4758,33 +3813,33 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 164 /* ArrowFunction */: - case 153 /* BindingElement */: - case 202 /* ClassDeclaration */: - case 136 /* Constructor */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 218 /* ExportSpecifier */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 137 /* GetAccessor */: - case 211 /* ImportClause */: - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 203 /* InterfaceDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 206 /* ModuleDeclaration */: - case 212 /* NamespaceImport */: - case 130 /* Parameter */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 138 /* SetAccessor */: - case 226 /* ShorthandPropertyAssignment */: - case 204 /* TypeAliasDeclaration */: - case 129 /* TypeParameter */: - case 199 /* VariableDeclaration */: + case 164: + case 153: + case 202: + case 136: + case 205: + case 227: + case 218: + case 201: + case 163: + case 137: + case 211: + case 209: + case 214: + case 203: + case 135: + case 134: + case 206: + case 212: + case 130: + case 225: + case 133: + case 132: + case 138: + case 226: + case 204: + case 129: + case 199: return true; } return false; @@ -4792,25 +3847,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 198 /* DebuggerStatement */: - case 185 /* DoStatement */: - case 183 /* ExpressionStatement */: - case 182 /* EmptyStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 184 /* IfStatement */: - case 195 /* LabeledStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: - case 94 /* ThrowKeyword */: - case 197 /* TryStatement */: - case 181 /* VariableStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 215 /* ExportAssignment */: + case 191: + case 190: + case 198: + case 185: + case 183: + case 182: + case 188: + case 189: + case 187: + case 184: + case 195: + case 192: + case 194: + case 94: + case 197: + case 181: + case 186: + case 193: + case 215: return true; default: return false; @@ -4819,26 +3874,25 @@ var ts; ts.isStatement = isStatement; function isClassElement(n) { switch (n.kind) { - case 136 /* Constructor */: - case 133 /* PropertyDeclaration */: - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: + case 136: + case 133: + case 135: + case 137: + case 138: + case 134: + case 141: return true; default: return false; } } ts.isClassElement = isClassElement; - // True if the given identifier, string literal, or number literal is the name of a declaration node function isDeclarationName(name) { - if (name.kind !== 65 /* Identifier */ && name.kind !== 8 /* StringLiteral */ && name.kind !== 7 /* NumericLiteral */) { + if (name.kind !== 65 && name.kind !== 8 && name.kind !== 7) { return false; } var parent = name.parent; - if (parent.kind === 214 /* ImportSpecifier */ || parent.kind === 218 /* ExportSpecifier */) { + if (parent.kind === 214 || parent.kind === 218) { if (parent.propertyName) { return true; } @@ -4849,35 +3903,27 @@ var ts; return false; } ts.isDeclarationName = isDeclarationName; - // An alias symbol is created by one of the following declarations: - // import = ... - // import from ... - // import * as from ... - // import { x as } from ... - // export { x as } from ... - // export = ... - // export default ... function isAliasSymbolDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ || - node.kind === 211 /* ImportClause */ && !!node.name || - node.kind === 212 /* NamespaceImport */ || - node.kind === 214 /* ImportSpecifier */ || - node.kind === 218 /* ExportSpecifier */ || - node.kind === 215 /* ExportAssignment */ && node.expression.kind === 65 /* Identifier */; + return node.kind === 209 || + node.kind === 211 && !!node.name || + node.kind === 212 || + node.kind === 214 || + node.kind === 218 || + node.kind === 215 && node.expression.kind === 65; } ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration; function getClassExtendsHeritageClauseElement(node) { - var heritageClause = getHeritageClause(node.heritageClauses, 79 /* ExtendsKeyword */); + var heritageClause = getHeritageClause(node.heritageClauses, 79); return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; } ts.getClassExtendsHeritageClauseElement = getClassExtendsHeritageClauseElement; function getClassImplementsHeritageClauseElements(node) { - var heritageClause = getHeritageClause(node.heritageClauses, 102 /* ImplementsKeyword */); + var heritageClause = getHeritageClause(node.heritageClauses, 102); return heritageClause ? heritageClause.types : undefined; } ts.getClassImplementsHeritageClauseElements = getClassImplementsHeritageClauseElements; function getInterfaceBaseTypeNodes(node) { - var heritageClause = getHeritageClause(node.heritageClauses, 79 /* ExtendsKeyword */); + var heritageClause = getHeritageClause(node.heritageClauses, 79); return heritageClause ? heritageClause.types : undefined; } ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes; @@ -4946,40 +3992,28 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 66 /* FirstKeyword */ <= token && token <= 126 /* LastKeyword */; + return 66 <= token && token <= 126; } ts.isKeyword = isKeyword; function isTrivia(token) { - return 2 /* FirstTriviaToken */ <= token && token <= 6 /* LastTriviaToken */; + return 2 <= token && token <= 6; } ts.isTrivia = isTrivia; - /** - * A declaration has a dynamic name if both of the following are true: - * 1. The declaration has a computed property name - * 2. The computed name is *not* expressed as Symbol., where name - * is a property of the Symbol constructor that denotes a built in - * Symbol. - */ function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 128 /* ComputedPropertyName */ && + declaration.name.kind === 128 && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; - /** - * Checks if the expression is of the form: - * Symbol.name - * where Symbol is literally the word "Symbol", and name is any identifierName - */ function isWellKnownSymbolSyntactically(node) { - return node.kind === 156 /* PropertyAccessExpression */ && isESSymbolIdentifier(node.expression); + return node.kind === 156 && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { - if (name.kind === 65 /* Identifier */ || name.kind === 8 /* StringLiteral */ || name.kind === 7 /* NumericLiteral */) { + if (name.kind === 65 || name.kind === 8 || name.kind === 7) { return name.text; } - if (name.kind === 128 /* ComputedPropertyName */) { + if (name.kind === 128) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -4993,30 +4027,27 @@ var ts; return "__@" + symbolName; } ts.getPropertyNameForKnownSymbolName = getPropertyNameForKnownSymbolName; - /** - * Includes the word "Symbol" with unicode escapes - */ function isESSymbolIdentifier(node) { - return node.kind === 65 /* Identifier */ && node.text === "Symbol"; + return node.kind === 65 && node.text === "Symbol"; } ts.isESSymbolIdentifier = isESSymbolIdentifier; function isModifier(token) { switch (token) { - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: - case 109 /* StaticKeyword */: - case 78 /* ExportKeyword */: - case 115 /* DeclareKeyword */: - case 70 /* ConstKeyword */: - case 73 /* DefaultKeyword */: + case 108: + case 106: + case 107: + case 109: + case 78: + case 115: + case 70: + case 73: return true; } return false; } ts.isModifier = isModifier; function nodeStartsNewLexicalEnvironment(n) { - return isFunctionLike(n) || n.kind === 206 /* ModuleDeclaration */ || n.kind === 228 /* SourceFile */; + return isFunctionLike(n) || n.kind === 206 || n.kind === 228; } ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; function nodeIsSynthesized(node) { @@ -5103,11 +4134,6 @@ var ts; } } ts.createDiagnosticCollection = createDiagnosticCollection; - // This consists of the first 19 unprintable ASCII characters, canonical escapes, lineSeparator, - // paragraphSeparator, and nextLine. The latter three are just desirable to suppress new lines in - // the language service. These characters should be escaped when printing, and if any characters are added, - // the map below must be updated. Note that this regexp *does not* include the 'delete' character. - // There is no reason for this other than that JSON.stringify does not handle it either. var escapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g; var escapedCharsMap = { "\0": "\\0", @@ -5121,13 +4147,8 @@ var ts; "\"": "\\\"", "\u2028": "\\u2028", "\u2029": "\\u2029", - "\u0085": "\\u0085" // nextLine + "\u0085": "\\u0085" }; - /** - * Based heavily on the abstract 'Quote'/'QuoteJSONString' operation from ECMA-262 (24.3.2.2), - * but augmented for a few select characters (e.g. lineSeparator, paragraphSeparator, nextLine) - * Note that this doesn't actually wrap the input in double quotes. - */ function escapeString(s) { s = escapedCharsRegExp.test(s) ? s.replace(escapedCharsRegExp, getReplacement) : s; return s; @@ -5143,8 +4164,6 @@ var ts; } var nonAsciiCharacters = /[^\u0000-\u007F]/g; function escapeNonAsciiCharacters(s) { - // Replace non-ASCII characters with '\uNNNN' escapes if any exist. - // Otherwise just return the original string. return nonAsciiCharacters.test(s) ? s.replace(nonAsciiCharacters, function (c) { return get16BitUnicodeEscapeSequence(c.charCodeAt(0)); }) : s; @@ -5191,7 +4210,7 @@ var ts; var lineStartsOfS = ts.computeLineStarts(s); if (lineStartsOfS.length > 1) { lineCount = lineCount + lineStartsOfS.length - 1; - linePos = output.length - s.length + lineStartsOfS[lineStartsOfS.length - 1]; + linePos = output.length - s.length + ts.lastOrUndefined(lineStartsOfS); } } } @@ -5252,7 +4271,7 @@ var ts; ts.getLineOfLocalPosition = getLineOfLocalPosition; function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 136 /* Constructor */ && nodeIsPresent(member.body)) { + if (member.kind === 136 && nodeIsPresent(member.body)) { return member; } }); @@ -5260,8 +4279,8 @@ var ts; ts.getFirstConstructorWithBody = getFirstConstructorWithBody; function shouldEmitToOwnFile(sourceFile, compilerOptions) { if (!isDeclarationFile(sourceFile)) { - if ((isExternalModule(sourceFile) || !compilerOptions.out) && !ts.fileExtensionIs(sourceFile.fileName, ".js")) { - return true; + if ((isExternalModule(sourceFile) || !compilerOptions.out)) { + return compilerOptions.separateCompilation || !ts.fileExtensionIs(sourceFile.fileName, ".js"); } return false; } @@ -5275,10 +4294,10 @@ var ts; var setAccessor; if (hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 137 /* GetAccessor */) { + if (accessor.kind === 137) { getAccessor = accessor; } - else if (accessor.kind === 138 /* SetAccessor */) { + else if (accessor.kind === 138) { setAccessor = accessor; } else { @@ -5287,8 +4306,8 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 137 /* GetAccessor */ || member.kind === 138 /* SetAccessor */) - && (member.flags & 128 /* Static */) === (accessor.flags & 128 /* Static */)) { + if ((member.kind === 137 || member.kind === 138) + && (member.flags & 128) === (accessor.flags & 128)) { var memberName = getPropertyNameForPropertyNameNode(member.name); var accessorName = getPropertyNameForPropertyNameNode(accessor.name); if (memberName === accessorName) { @@ -5298,10 +4317,10 @@ var ts; else if (!secondAccessor) { secondAccessor = member; } - if (member.kind === 137 /* GetAccessor */ && !getAccessor) { + if (member.kind === 137 && !getAccessor) { getAccessor = member; } - if (member.kind === 138 /* SetAccessor */ && !setAccessor) { + if (member.kind === 138 && !setAccessor) { setAccessor = member; } } @@ -5317,7 +4336,6 @@ var ts; } ts.getAllAccessorDeclarations = getAllAccessorDeclarations; function emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments) { - // If the leading comments start on different line than the start of node, write new line if (leadingComments && leadingComments.length && node.pos !== leadingComments[0].pos && getLineOfLocalPosition(currentSourceFile, node.pos) !== getLineOfLocalPosition(currentSourceFile, leadingComments[0].pos)) { writer.writeLine(); @@ -5339,14 +4357,13 @@ var ts; writer.write(" "); } else { - // Emit leading space to separate comment during next comment emit emitLeadingSpace = true; } }); } ts.emitComments = emitComments; function writeCommentRange(currentSourceFile, writer, comment, newLine) { - if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */) { + if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42) { var firstCommentLineAndCharacter = ts.getLineAndCharacterOfPosition(currentSourceFile, comment.pos); var lineCount = ts.getLineStarts(currentSourceFile).length; var firstCommentLineIndent; @@ -5355,76 +4372,51 @@ var ts; ? currentSourceFile.text.length + 1 : getStartPositionOfLine(currentLine + 1, currentSourceFile); if (pos !== comment.pos) { - // If we are not emitting first line, we need to write the spaces to adjust the alignment if (firstCommentLineIndent === undefined) { firstCommentLineIndent = calculateIndent(getStartPositionOfLine(firstCommentLineAndCharacter.line, currentSourceFile), comment.pos); } - // These are number of spaces writer is going to write at current indent var currentWriterIndentSpacing = writer.getIndent() * getIndentSize(); - // Number of spaces we want to be writing - // eg: Assume writer indent - // module m { - // /* starts at character 9 this is line 1 - // * starts at character pos 4 line --1 = 8 - 8 + 3 - // More left indented comment */ --2 = 8 - 8 + 2 - // class c { } - // } - // module m { - // /* this is line 1 -- Assume current writer indent 8 - // * line --3 = 8 - 4 + 5 - // More right indented comment */ --4 = 8 - 4 + 11 - // class c { } - // } var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(pos, nextLineStart); if (spacesToEmit > 0) { var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize(); var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize()); - // Write indent size string ( in eg 1: = "", 2: "" , 3: string with 8 spaces 4: string with 12 spaces writer.rawWrite(indentSizeSpaceString); - // Emit the single spaces (in eg: 1: 3 spaces, 2: 2 spaces, 3: 1 space, 4: 3 spaces) while (numberOfSingleSpacesToEmit) { writer.rawWrite(" "); numberOfSingleSpacesToEmit--; } } else { - // No spaces to emit write empty string writer.rawWrite(""); } } - // Write the comment line text writeTrimmedCurrentLine(pos, nextLineStart); pos = nextLineStart; } } else { - // Single line comment of style //.... writer.write(currentSourceFile.text.substring(comment.pos, comment.end)); } function writeTrimmedCurrentLine(pos, nextLineStart) { var end = Math.min(comment.end, nextLineStart - 1); var currentLineText = currentSourceFile.text.substring(pos, end).replace(/^\s+|\s+$/g, ''); if (currentLineText) { - // trimmed forward and ending spaces text writer.write(currentLineText); if (end !== comment.end) { writer.writeLine(); } } else { - // Empty string - make sure we write empty line writer.writeLiteral(newLine); } } function calculateIndent(pos, end) { var currentLineIndent = 0; for (; pos < end && ts.isWhiteSpace(currentSourceFile.text.charCodeAt(pos)); pos++) { - if (currentSourceFile.text.charCodeAt(pos) === 9 /* tab */) { - // Tabs = TabSize = indent size and go to next tabStop + if (currentSourceFile.text.charCodeAt(pos) === 9) { currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize()); } else { - // Single space currentLineIndent++; } } @@ -5434,14 +4426,14 @@ var ts; ts.writeCommentRange = writeCommentRange; function modifierToFlag(token) { switch (token) { - case 109 /* StaticKeyword */: return 128 /* Static */; - case 108 /* PublicKeyword */: return 16 /* Public */; - case 107 /* ProtectedKeyword */: return 64 /* Protected */; - case 106 /* PrivateKeyword */: return 32 /* Private */; - case 78 /* ExportKeyword */: return 1 /* Export */; - case 115 /* DeclareKeyword */: return 2 /* Ambient */; - case 70 /* ConstKeyword */: return 8192 /* Const */; - case 73 /* DefaultKeyword */: return 256 /* Default */; + case 109: return 128; + case 108: return 16; + case 107: return 64; + case 106: return 32; + case 78: return 1; + case 115: return 2; + case 70: return 8192; + case 73: return 256; } return 0; } @@ -5449,27 +4441,27 @@ var ts; function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 159 /* NewExpression */: - case 158 /* CallExpression */: - case 160 /* TaggedTemplateExpression */: - case 154 /* ArrayLiteralExpression */: - case 162 /* ParenthesizedExpression */: - case 155 /* ObjectLiteralExpression */: - case 175 /* ClassExpression */: - case 163 /* FunctionExpression */: - case 65 /* Identifier */: - case 9 /* RegularExpressionLiteral */: - case 7 /* NumericLiteral */: - case 8 /* StringLiteral */: - case 10 /* NoSubstitutionTemplateLiteral */: - case 172 /* TemplateExpression */: - case 80 /* FalseKeyword */: - case 89 /* NullKeyword */: - case 93 /* ThisKeyword */: - case 95 /* TrueKeyword */: - case 91 /* SuperKeyword */: + case 156: + case 157: + case 159: + case 158: + case 160: + case 154: + case 162: + case 155: + case 175: + case 163: + case 65: + case 9: + case 7: + case 8: + case 10: + case 172: + case 80: + case 89: + case 93: + case 95: + case 91: return true; } } @@ -5477,20 +4469,18 @@ var ts; } ts.isLeftHandSideExpression = isLeftHandSideExpression; function isAssignmentOperator(token) { - return token >= 53 /* FirstAssignment */ && token <= 64 /* LastAssignment */; + return token >= 53 && token <= 64; } ts.isAssignmentOperator = isAssignmentOperator; - // Returns false if this heritage clause element's expression contains something unsupported - // (i.e. not a name or dotted name). function isSupportedExpressionWithTypeArguments(node) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } ts.isSupportedExpressionWithTypeArguments = isSupportedExpressionWithTypeArguments; function isSupportedExpressionWithTypeArgumentsRest(node) { - if (node.kind === 65 /* Identifier */) { + if (node.kind === 65) { return true; } - else if (node.kind === 156 /* PropertyAccessExpression */) { + else if (node.kind === 156) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } else { @@ -5498,25 +4488,20 @@ var ts; } } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node) || - (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node); + return (node.parent.kind === 127 && node.parent.right === node) || + (node.parent.kind === 156 && node.parent.name === node); } ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; function getLocalSymbolForExportDefault(symbol) { - return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 256 /* Default */) ? symbol.valueDeclaration.localSymbol : undefined; + return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 256) ? symbol.valueDeclaration.localSymbol : undefined; } ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault; - /** - * Replace each instance of non-ascii characters by one, two, three, or four escape sequences - * representing the UTF-8 encoding of the character, and return the expanded char code list. - */ function getExpandedCharCodes(input) { var output = []; var length = input.length; var leadSurrogate = undefined; for (var i = 0; i < length; i++) { var charCode = input.charCodeAt(i); - // handel utf8 if (charCode < 0x80) { output.push(charCode); } @@ -5542,9 +4527,6 @@ var ts; return output; } var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; - /** - * Converts a string to a base-64 encoded ASCII string. - */ function convertToBase64(input) { var result = ""; var charCodes = getExpandedCharCodes(input); @@ -5552,21 +4534,16 @@ var ts; var length = charCodes.length; var byte1, byte2, byte3, byte4; while (i < length) { - // Convert every 6-bits in the input 3 character points - // into a base64 digit byte1 = charCodes[i] >> 2; byte2 = (charCodes[i] & 3) << 4 | charCodes[i + 1] >> 4; byte3 = (charCodes[i + 1] & 15) << 2 | charCodes[i + 2] >> 6; byte4 = charCodes[i + 2] & 63; - // We are out of characters in the input, set the extra - // digits to 64 (padding character). if (i + 1 >= length) { byte3 = byte4 = 64; } else if (i + 2 >= length) { byte4 = 64; } - // Write to the ouput result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4); i += 3; } @@ -5577,7 +4554,7 @@ var ts; var ts; (function (ts) { function getDefaultLibFileName(options) { - return options.target === 2 /* ES6 */ ? "lib.es6.d.ts" : "lib.d.ts"; + return options.target === 2 ? "lib.es6.d.ts" : "lib.d.ts"; } ts.getDefaultLibFileName = getDefaultLibFileName; function textSpanEnd(span) { @@ -5592,7 +4569,6 @@ var ts; return position >= span.start && position < textSpanEnd(span); } ts.textSpanContainsPosition = textSpanContainsPosition; - // Returns true if 'span' contains 'other'. function textSpanContainsTextSpan(span, other) { return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span); } @@ -5664,14 +4640,6 @@ var ts; } ts.createTextChangeRange = createTextChangeRange; ts.unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0); - /** - * Called to merge all the changes that occurred across several versions of a script snapshot - * into a single change. i.e. if a user keeps making successive edits to a script we will - * have a text change from V1 to V2, V2 to V3, ..., Vn. - * - * This function will then merge those changes into a single change range valid between V1 and - * Vn. - */ function collapseTextChangeRangesAcrossMultipleVersions(changes) { if (changes.length === 0) { return ts.unchangedTextChangeRange; @@ -5679,93 +4647,12 @@ var ts; if (changes.length === 1) { return changes[0]; } - // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd } - // as it makes things much easier to reason about. var change0 = changes[0]; var oldStartN = change0.span.start; var oldEndN = textSpanEnd(change0.span); var newEndN = oldStartN + change0.newLength; for (var i = 1; i < changes.length; i++) { var nextChange = changes[i]; - // Consider the following case: - // i.e. two edits. The first represents the text change range { { 10, 50 }, 30 }. i.e. The span starting - // at 10, with length 50 is reduced to length 30. The second represents the text change range { { 30, 30 }, 40 }. - // i.e. the span starting at 30 with length 30 is increased to length 40. - // - // 0 10 20 30 40 50 60 70 80 90 100 - // ------------------------------------------------------------------------------------------------------- - // | / - // | /---- - // T1 | /---- - // | /---- - // | /---- - // ------------------------------------------------------------------------------------------------------- - // | \ - // | \ - // T2 | \ - // | \ - // | \ - // ------------------------------------------------------------------------------------------------------- - // - // Merging these turns out to not be too difficult. First, determining the new start of the change is trivial - // it's just the min of the old and new starts. i.e.: - // - // 0 10 20 30 40 50 60 70 80 90 100 - // ------------------------------------------------------------*------------------------------------------ - // | / - // | /---- - // T1 | /---- - // | /---- - // | /---- - // ----------------------------------------$-------------------$------------------------------------------ - // . | \ - // . | \ - // T2 . | \ - // . | \ - // . | \ - // ----------------------------------------------------------------------*-------------------------------- - // - // (Note the dots represent the newly inferrred start. - // Determining the new and old end is also pretty simple. Basically it boils down to paying attention to the - // absolute positions at the asterixes, and the relative change between the dollar signs. Basically, we see - // which if the two $'s precedes the other, and we move that one forward until they line up. in this case that - // means: - // - // 0 10 20 30 40 50 60 70 80 90 100 - // --------------------------------------------------------------------------------*---------------------- - // | / - // | /---- - // T1 | /---- - // | /---- - // | /---- - // ------------------------------------------------------------$------------------------------------------ - // . | \ - // . | \ - // T2 . | \ - // . | \ - // . | \ - // ----------------------------------------------------------------------*-------------------------------- - // - // In other words (in this case), we're recognizing that the second edit happened after where the first edit - // ended with a delta of 20 characters (60 - 40). Thus, if we go back in time to where the first edit started - // that's the same as if we started at char 80 instead of 60. - // - // As it so happens, the same logic applies if the second edit precedes the first edit. In that case rahter - // than pusing the first edit forward to match the second, we'll push the second edit forward to match the - // first. - // - // In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange - // semantics: { { start: 10, length: 70 }, newLength: 60 } - // - // The math then works out as follows. - // If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the - // final result like so: - // - // { - // oldStart3: Min(oldStart1, oldStart2), - // oldEnd3 : Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)), - // newEnd3 : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)) - // } var oldStart1 = oldStartN; var oldEnd1 = oldEndN; var newEnd1 = newEndN; @@ -5784,8 +4671,8 @@ var ts; /// var ts; (function (ts) { - var nodeConstructors = new Array(230 /* Count */); - /* @internal */ ts.parseTime = 0; + var nodeConstructors = new Array(230); + ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); } @@ -5815,34 +4702,27 @@ var ts; } } } - // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes - // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise, - // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns - // a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned. function forEachChild(node, cbNode, cbNodeArray) { if (!node) { return; } - // The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray - // callback parameters, but that causes a closure allocation for each invocation with noticeable effects - // on performance. var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 127 /* QualifiedName */: + case 127: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 129 /* TypeParameter */: + case 129: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 130: + case 133: + case 132: + case 225: + case 226: + case 199: + case 153: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || @@ -5851,24 +4731,24 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 143: + case 144: + case 139: + case 140: + case 141: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: + case 135: + case 134: + case 136: + case 137: + case 138: + case 163: + case 201: + case 164: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || @@ -5879,220 +4759,220 @@ var ts; visitNode(cbNode, node.type) || visitNode(cbNode, node.equalsGreaterThanToken) || visitNode(cbNode, node.body); - case 142 /* TypeReference */: + case 142: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 145 /* TypeQuery */: + case 145: return visitNode(cbNode, node.exprName); - case 146 /* TypeLiteral */: + case 146: return visitNodes(cbNodes, node.members); - case 147 /* ArrayType */: + case 147: return visitNode(cbNode, node.elementType); - case 148 /* TupleType */: + case 148: return visitNodes(cbNodes, node.elementTypes); - case 149 /* UnionType */: + case 149: return visitNodes(cbNodes, node.types); - case 150 /* ParenthesizedType */: + case 150: return visitNode(cbNode, node.type); - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: + case 151: + case 152: return visitNodes(cbNodes, node.elements); - case 154 /* ArrayLiteralExpression */: + case 154: return visitNodes(cbNodes, node.elements); - case 155 /* ObjectLiteralExpression */: + case 155: return visitNodes(cbNodes, node.properties); - case 156 /* PropertyAccessExpression */: + case 156: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.dotToken) || visitNode(cbNode, node.name); - case 157 /* ElementAccessExpression */: + case 157: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 158: + case 159: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 160 /* TaggedTemplateExpression */: + case 160: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 161 /* TypeAssertionExpression */: + case 161: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 162 /* ParenthesizedExpression */: + case 162: return visitNode(cbNode, node.expression); - case 165 /* DeleteExpression */: + case 165: return visitNode(cbNode, node.expression); - case 166 /* TypeOfExpression */: + case 166: return visitNode(cbNode, node.expression); - case 167 /* VoidExpression */: + case 167: return visitNode(cbNode, node.expression); - case 168 /* PrefixUnaryExpression */: + case 168: return visitNode(cbNode, node.operand); - case 173 /* YieldExpression */: + case 173: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 169 /* PostfixUnaryExpression */: + case 169: return visitNode(cbNode, node.operand); - case 170 /* BinaryExpression */: + case 170: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 171 /* ConditionalExpression */: + case 171: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.colonToken) || visitNode(cbNode, node.whenFalse); - case 174 /* SpreadElementExpression */: + case 174: return visitNode(cbNode, node.expression); - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 180: + case 207: return visitNodes(cbNodes, node.statements); - case 228 /* SourceFile */: + case 228: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 181 /* VariableStatement */: + case 181: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 200 /* VariableDeclarationList */: + case 200: return visitNodes(cbNodes, node.declarations); - case 183 /* ExpressionStatement */: + case 183: return visitNode(cbNode, node.expression); - case 184 /* IfStatement */: + case 184: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 185 /* DoStatement */: + case 185: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 186 /* WhileStatement */: + case 186: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 187 /* ForStatement */: + case 187: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.incrementor) || visitNode(cbNode, node.statement); - case 188 /* ForInStatement */: + case 188: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 189 /* ForOfStatement */: + case 189: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 190: + case 191: return visitNode(cbNode, node.label); - case 192 /* ReturnStatement */: + case 192: return visitNode(cbNode, node.expression); - case 193 /* WithStatement */: + case 193: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 194 /* SwitchStatement */: + case 194: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.caseBlock); - case 208 /* CaseBlock */: + case 208: return visitNodes(cbNodes, node.clauses); - case 221 /* CaseClause */: + case 221: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.statements); - case 222 /* DefaultClause */: + case 222: return visitNodes(cbNodes, node.statements); - case 195 /* LabeledStatement */: + case 195: return visitNode(cbNode, node.label) || visitNode(cbNode, node.statement); - case 196 /* ThrowStatement */: + case 196: return visitNode(cbNode, node.expression); - case 197 /* TryStatement */: + case 197: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 224 /* CatchClause */: + case 224: return visitNode(cbNode, node.variableDeclaration) || visitNode(cbNode, node.block); - case 131 /* Decorator */: + case 131: return visitNode(cbNode, node.expression); - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: + case 202: + case 175: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 203 /* InterfaceDeclaration */: + case 203: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 204 /* TypeAliasDeclaration */: + case 204: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.type); - case 205 /* EnumDeclaration */: + case 205: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.members); - case 227 /* EnumMember */: + case 227: return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); - case 206 /* ModuleDeclaration */: + case 206: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); - case 209 /* ImportEqualsDeclaration */: + case 209: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 210 /* ImportDeclaration */: + case 210: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.importClause) || visitNode(cbNode, node.moduleSpecifier); - case 211 /* ImportClause */: + case 211: return visitNode(cbNode, node.name) || visitNode(cbNode, node.namedBindings); - case 212 /* NamespaceImport */: + case 212: return visitNode(cbNode, node.name); - case 213 /* NamedImports */: - case 217 /* NamedExports */: + case 213: + case 217: return visitNodes(cbNodes, node.elements); - case 216 /* ExportDeclaration */: + case 216: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportClause) || visitNode(cbNode, node.moduleSpecifier); - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 214: + case 218: return visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name); - case 215 /* ExportAssignment */: + case 215: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.expression); - case 172 /* TemplateExpression */: + case 172: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 178 /* TemplateSpan */: + case 178: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 128 /* ComputedPropertyName */: + case 128: return visitNode(cbNode, node.expression); - case 223 /* HeritageClause */: + case 223: return visitNodes(cbNodes, node.types); - case 177 /* ExpressionWithTypeArguments */: + case 177: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments); - case 220 /* ExternalModuleReference */: + case 220: return visitNode(cbNode, node.expression); - case 219 /* MissingDeclaration */: + case 219: return visitNodes(cbNodes, node.decorators); } } @@ -6105,28 +4985,14 @@ var ts; return result; } ts.createSourceFile = createSourceFile; - // Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter - // indicates what changed between the 'text' that this SourceFile has and the 'newText'. - // The SourceFile will be created with the compiler attempting to reuse as many nodes from - // this file as possible. - // - // Note: this function mutates nodes from this SourceFile. That means any existing nodes - // from this SourceFile that are being held onto may change as a result (including - // becoming detached from any SourceFile). It is recommended that this SourceFile not - // be used once 'update' is called on it. function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) { return IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks); } ts.updateSourceFile = updateSourceFile; - // Implement the parser as a singleton module. We do this for perf reasons because creating - // parser instances can actually be expensive enough to impact us on projects with many source - // files. var Parser; (function (Parser) { - // Share a single scanner across all calls to parse a source file. This helps speed things - // up by avoiding the cost of creating/compiling scanners over and over again. - var scanner = ts.createScanner(2 /* Latest */, true); - var disallowInAndDecoratorContext = 2 /* DisallowIn */ | 16 /* Decorator */; + var scanner = ts.createScanner(2, true); + var disallowInAndDecoratorContext = 2 | 16; var sourceFile; var syntaxCursor; var token; @@ -6135,80 +5001,7 @@ var ts; var identifiers; var identifierCount; var parsingContext; - // Flags that dictate what parsing context we're in. For example: - // Whether or not we are in strict parsing mode. All that changes in strict parsing mode is - // that some tokens that would be considered identifiers may be considered keywords. - // - // When adding more parser context flags, consider which is the more common case that the - // flag will be in. This should be the 'false' state for that flag. The reason for this is - // that we don't store data in our nodes unless the value is in the *non-default* state. So, - // for example, more often than code 'allows-in' (or doesn't 'disallow-in'). We opt for - // 'disallow-in' set to 'false'. Otherwise, if we had 'allowsIn' set to 'true', then almost - // all nodes would need extra state on them to store this info. - // - // Note: 'allowIn' and 'allowYield' track 1:1 with the [in] and [yield] concepts in the ES6 - // grammar specification. - // - // An important thing about these context concepts. By default they are effectively inherited - // while parsing through every grammar production. i.e. if you don't change them, then when - // you parse a sub-production, it will have the same context values as the parent production. - // This is great most of the time. After all, consider all the 'expression' grammar productions - // and how nearly all of them pass along the 'in' and 'yield' context values: - // - // EqualityExpression[In, Yield] : - // RelationalExpression[?In, ?Yield] - // EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield] - // EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield] - // EqualityExpression[?In, ?Yield] === RelationalExpression[?In, ?Yield] - // EqualityExpression[?In, ?Yield] !== RelationalExpression[?In, ?Yield] - // - // Where you have to be careful is then understanding what the points are in the grammar - // where the values are *not* passed along. For example: - // - // SingleNameBinding[Yield,GeneratorParameter] - // [+GeneratorParameter]BindingIdentifier[Yield] Initializer[In]opt - // [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt - // - // Here this is saying that if the GeneratorParameter context flag is set, that we should - // explicitly set the 'yield' context flag to false before calling into the BindingIdentifier - // and we should explicitly unset the 'yield' context flag before calling into the Initializer. - // production. Conversely, if the GeneratorParameter context flag is not set, then we - // should leave the 'yield' context flag alone. - // - // Getting this all correct is tricky and requires careful reading of the grammar to - // understand when these values should be changed versus when they should be inherited. - // - // Note: it should not be necessary to save/restore these flags during speculative/lookahead - // parsing. These context flags are naturally stored and restored through normal recursive - // descent parsing and unwinding. var contextFlags = 0; - // Whether or not we've had a parse error since creating the last AST node. If we have - // encountered an error, it will be stored on the next AST node we create. Parse errors - // can be broken down into three categories: - // - // 1) An error that occurred during scanning. For example, an unterminated literal, or a - // character that was completely not understood. - // - // 2) A token was expected, but was not present. This type of error is commonly produced - // by the 'parseExpected' function. - // - // 3) A token was present that no parsing function was able to consume. This type of error - // only occurs in the 'abortParsingListOrMoveToNextToken' function when the parser - // decides to skip the token. - // - // In all of these cases, we want to mark the next node as having had an error before it. - // With this mark, we can know in incremental settings if this node can be reused, or if - // we have to reparse it. If we don't keep this information around, we may just reuse the - // node. in that event we would then not produce the same errors as we did before, causing - // significant confusion problems. - // - // Note: it is necessary that this value be saved/restored during speculative/lookahead - // parsing. During lookahead parsing, we will often create a node. That node will have - // this value attached, and then this value will be set back to 'false'. If we decide to - // rewind, we must get back to the same value we had prior to the lookahead. - // - // Note: any errors at the end of the file that do not precede a regular node, should get - // attached to the EOF token. var parseErrorBeforeNextFinishedNode = false; function parseSourceFile(fileName, _sourceText, languageVersion, _syntaxCursor, setParentNodes) { sourceText = _sourceText; @@ -6220,14 +5013,13 @@ var ts; contextFlags = 0; parseErrorBeforeNextFinishedNode = false; createSourceFile(fileName, languageVersion); - // Initialize and prime the scanner before parsing the source elements. scanner.setText(sourceText); scanner.setOnError(scanError); scanner.setScriptTarget(languageVersion); token = nextToken(); processReferenceComments(sourceFile); - sourceFile.statements = parseList(0 /* SourceElements */, true, parseSourceElement); - ts.Debug.assert(token === 1 /* EndOfFileToken */); + sourceFile.statements = parseList(0, true, parseSourceElement); + ts.Debug.assert(token === 1); sourceFile.endOfFileToken = parseTokenNode(); setExternalModuleIndicator(sourceFile); sourceFile.nodeCount = nodeCount; @@ -6237,11 +5029,9 @@ var ts; fixupParentReferences(sourceFile); } syntaxCursor = undefined; - // Clear out the text the scanner is pointing at, so it doesn't keep anything alive unnecessarily. scanner.setText(""); scanner.setOnError(undefined); var result = sourceFile; - // Clear any data. We don't want to accidently hold onto it for too long. sourceFile = undefined; identifiers = undefined; syntaxCursor = undefined; @@ -6258,9 +5048,6 @@ var ts; forEachChild(sourceFile, visitNode); return; function visitNode(n) { - // walk down setting parents that differ from the parent we think it should be. This - // allows us to quickly bail out of setting parents for subtrees during incremental - // parsing if (n.parent !== parent) { n.parent = parent; var saveParent = parent; @@ -6271,7 +5058,7 @@ var ts; } } function createSourceFile(fileName, languageVersion) { - sourceFile = createNode(228 /* SourceFile */, 0); + sourceFile = createNode(228, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -6279,7 +5066,7 @@ var ts; sourceFile.bindDiagnostics = []; sourceFile.languageVersion = languageVersion; sourceFile.fileName = ts.normalizePath(fileName); - sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 2048 /* DeclarationFile */ : 0; + sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 2048 : 0; } function setContextFlag(val, flag) { if (val) { @@ -6290,19 +5077,19 @@ var ts; } } function setStrictModeContext(val) { - setContextFlag(val, 1 /* StrictMode */); + setContextFlag(val, 1); } function setDisallowInContext(val) { - setContextFlag(val, 2 /* DisallowIn */); + setContextFlag(val, 2); } function setYieldContext(val) { - setContextFlag(val, 4 /* Yield */); + setContextFlag(val, 4); } function setGeneratorParameterContext(val) { - setContextFlag(val, 8 /* GeneratorParameter */); + setContextFlag(val, 8); } function setDecoratorContext(val) { - setContextFlag(val, 16 /* Decorator */); + setContextFlag(val, 16); } function doOutsideOfContext(flags, func) { var currentContextFlags = contextFlags & flags; @@ -6312,22 +5099,19 @@ var ts; setContextFlag(true, currentContextFlags); return result; } - // no need to do anything special as we are not in any of the requested contexts return func(); } function allowInAnd(func) { - if (contextFlags & 2 /* DisallowIn */) { + if (contextFlags & 2) { setDisallowInContext(false); var result = func(); setDisallowInContext(true); return result; } - // no need to do anything special if 'in' is already allowed. return func(); } function disallowInAnd(func) { - if (contextFlags & 2 /* DisallowIn */) { - // no need to do anything special if 'in' is already disallowed. + if (contextFlags & 2) { return func(); } setDisallowInContext(true); @@ -6336,8 +5120,7 @@ var ts; return result; } function doInYieldContext(func) { - if (contextFlags & 4 /* Yield */) { - // no need to do anything special if we're already in the [Yield] context. + if (contextFlags & 4) { return func(); } setYieldContext(true); @@ -6346,18 +5129,16 @@ var ts; return result; } function doOutsideOfYieldContext(func) { - if (contextFlags & 4 /* Yield */) { + if (contextFlags & 4) { setYieldContext(false); var result = func(); setYieldContext(true); return result; } - // no need to do anything special if we're not in the [Yield] context. return func(); } function doInDecoratorContext(func) { - if (contextFlags & 16 /* Decorator */) { - // no need to do anything special if we're already in the [Decorator] context. + if (contextFlags & 16) { return func(); } setDecoratorContext(true); @@ -6366,19 +5147,19 @@ var ts; return result; } function inYieldContext() { - return (contextFlags & 4 /* Yield */) !== 0; + return (contextFlags & 4) !== 0; } function inStrictModeContext() { - return (contextFlags & 1 /* StrictMode */) !== 0; + return (contextFlags & 1) !== 0; } function inGeneratorParameterContext() { - return (contextFlags & 8 /* GeneratorParameter */) !== 0; + return (contextFlags & 8) !== 0; } function inDisallowInContext() { - return (contextFlags & 2 /* DisallowIn */) !== 0; + return (contextFlags & 2) !== 0; } function inDecoratorContext() { - return (contextFlags & 16 /* Decorator */) !== 0; + return (contextFlags & 16) !== 0; } function parseErrorAtCurrentToken(message, arg0) { var start = scanner.getTokenPos(); @@ -6386,13 +5167,10 @@ var ts; parseErrorAtPosition(start, length, message, arg0); } function parseErrorAtPosition(start, length, message, arg0) { - // Don't report another error if it would just be at the same position as the last error. var lastError = ts.lastOrUndefined(sourceFile.parseDiagnostics); if (!lastError || start !== lastError.start) { sourceFile.parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, start, length, message, arg0)); } - // Mark that we've encountered an error. We'll set an appropriate bit on the next - // node we finish so that it can't be reused incrementally. parseErrorBeforeNextFinishedNode = true; } function scanError(message, length) { @@ -6421,25 +5199,14 @@ var ts; return token = scanner.reScanTemplateToken(); } function speculationHelper(callback, isLookAhead) { - // Keep track of the state we'll need to rollback to if lookahead fails (or if the - // caller asked us to always reset our state). var saveToken = token; var saveParseDiagnosticsLength = sourceFile.parseDiagnostics.length; var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; - // Note: it is not actually necessary to save/restore the context flags here. That's - // because the saving/restorating of these flags happens naturally through the recursive - // descent nature of our parser. However, we still store this here just so we can - // assert that that invariant holds. var saveContextFlags = contextFlags; - // If we're only looking ahead, then tell the scanner to only lookahead as well. - // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the - // same. var result = isLookAhead ? scanner.lookAhead(callback) : scanner.tryScan(callback); ts.Debug.assert(saveContextFlags === contextFlags); - // If our callback returned something 'falsy' or we're just looking ahead, - // then unconditionally restore us to where we were. if (!result || isLookAhead) { token = saveToken; sourceFile.parseDiagnostics.length = saveParseDiagnosticsLength; @@ -6447,37 +5214,26 @@ var ts; } return result; } - // Invokes the provided callback then unconditionally restores the parser to the state it - // was in immediately prior to invoking the callback. The result of invoking the callback - // is returned from this function. function lookAhead(callback) { return speculationHelper(callback, true); } - // Invokes the provided callback. If the callback returns something falsy, then it restores - // the parser to the state it was in immediately prior to invoking the callback. If the - // callback returns something truthy, then the parser state is not rolled back. The result - // of invoking the callback is returned from this function. function tryParse(callback) { return speculationHelper(callback, false); } - // Ignore strict mode flag because we will report an error in type checker instead. function isIdentifier() { - if (token === 65 /* Identifier */) { + if (token === 65) { return true; } - // If we have a 'yield' keyword, and we're in the [yield] context, then 'yield' is - // considered a keyword and is not an identifier. - if (token === 110 /* YieldKeyword */ && inYieldContext()) { + if (token === 110 && inYieldContext()) { return false; } - return token > 101 /* LastReservedWord */; + return token > 101; } function parseExpected(kind, diagnosticMessage) { if (token === kind) { nextToken(); return true; } - // Report specific message if provided with one. Otherwise, report generic fallback message. if (diagnosticMessage) { parseErrorAtCurrentToken(diagnosticMessage); } @@ -6509,23 +5265,20 @@ var ts; return finishNode(node); } function canParseSemicolon() { - // If there's a real semicolon, then we can always parse it out. - if (token === 22 /* SemicolonToken */) { + if (token === 22) { return true; } - // We can parse out an optional semicolon in ASI cases in the following cases. - return token === 15 /* CloseBraceToken */ || token === 1 /* EndOfFileToken */ || scanner.hasPrecedingLineBreak(); + return token === 15 || token === 1 || scanner.hasPrecedingLineBreak(); } function parseSemicolon() { if (canParseSemicolon()) { - if (token === 22 /* SemicolonToken */) { - // consume the semicolon if it was explicitly provided. + if (token === 22) { nextToken(); } return true; } else { - return parseExpected(22 /* SemicolonToken */); + return parseExpected(22); } } function createNode(kind, pos) { @@ -6543,12 +5296,9 @@ var ts; if (contextFlags) { node.parserContextFlags = contextFlags; } - // Keep track on the node if we encountered an error while parsing it. If we did, then - // we cannot reuse the node incrementally. Once we've marked this node, clear out the - // flag so that we don't mark any subsequent nodes. if (parseErrorBeforeNextFinishedNode) { parseErrorBeforeNextFinishedNode = false; - node.parserContextFlags |= 32 /* ThisNodeHasError */; + node.parserContextFlags |= 32; } return node; } @@ -6567,22 +5317,18 @@ var ts; text = ts.escapeIdentifier(text); return ts.hasProperty(identifiers, text) ? identifiers[text] : (identifiers[text] = text); } - // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues - // with magic property names like '__proto__'. The 'identifiers' object is used to share a single string instance for - // each identifier in order to reduce memory consumption. function createIdentifier(isIdentifier, diagnosticMessage) { identifierCount++; if (isIdentifier) { - var node = createNode(65 /* Identifier */); - // Store original token kind if it is not just an Identifier so we can report appropriate error later in type checker - if (token !== 65 /* Identifier */) { + var node = createNode(65); + if (token !== 65) { node.originalKeywordKind = token; } node.text = internIdentifier(scanner.getTokenValue()); nextToken(); return finishNode(node); } - return createMissingNode(65 /* Identifier */, false, diagnosticMessage || ts.Diagnostics.Identifier_expected); + return createMissingNode(65, false, diagnosticMessage || ts.Diagnostics.Identifier_expected); } function parseIdentifier(diagnosticMessage) { return createIdentifier(isIdentifier(), diagnosticMessage); @@ -6592,32 +5338,21 @@ var ts; } function isLiteralPropertyName() { return isIdentifierOrKeyword() || - token === 8 /* StringLiteral */ || - token === 7 /* NumericLiteral */; + token === 8 || + token === 7; } function parsePropertyName() { - if (token === 8 /* StringLiteral */ || token === 7 /* NumericLiteral */) { + if (token === 8 || token === 7) { return parseLiteralNode(true); } - if (token === 18 /* OpenBracketToken */) { + if (token === 18) { return parseComputedPropertyName(); } return parseIdentifierName(); } function parseComputedPropertyName() { - // PropertyName[Yield,GeneratorParameter] : - // LiteralPropertyName - // [+GeneratorParameter] ComputedPropertyName - // [~GeneratorParameter] ComputedPropertyName[?Yield] - // - // ComputedPropertyName[Yield] : - // [ AssignmentExpression[In, ?Yield] ] - // - var node = createNode(128 /* ComputedPropertyName */); - parseExpected(18 /* OpenBracketToken */); - // We parse any expression (including a comma expression). But the grammar - // says that only an assignment expression is allowed, so the grammar checker - // will error if it sees a comma expression. + var node = createNode(128); + parseExpected(18); var yieldContext = inYieldContext(); if (inGeneratorParameterContext()) { setYieldContext(false); @@ -6626,7 +5361,7 @@ var ts; if (inGeneratorParameterContext()) { setYieldContext(yieldContext); } - parseExpected(19 /* CloseBracketToken */); + parseExpected(19); return finishNode(node); } function parseContextualModifier(t) { @@ -6640,112 +5375,92 @@ var ts; return ts.isModifier(token) && tryParse(nextTokenCanFollowContextualModifier); } function nextTokenCanFollowContextualModifier() { - if (token === 70 /* ConstKeyword */) { - // 'const' is only a modifier if followed by 'enum'. - return nextToken() === 77 /* EnumKeyword */; + if (token === 70) { + return nextToken() === 77; } - if (token === 78 /* ExportKeyword */) { + if (token === 78) { nextToken(); - if (token === 73 /* DefaultKeyword */) { + if (token === 73) { return lookAhead(nextTokenIsClassOrFunction); } - return token !== 35 /* AsteriskToken */ && token !== 14 /* OpenBraceToken */ && canFollowModifier(); + return token !== 35 && token !== 14 && canFollowModifier(); } - if (token === 73 /* DefaultKeyword */) { + if (token === 73) { return nextTokenIsClassOrFunction(); } nextToken(); return canFollowModifier(); } function canFollowModifier() { - return token === 18 /* OpenBracketToken */ - || token === 14 /* OpenBraceToken */ - || token === 35 /* AsteriskToken */ + return token === 18 + || token === 14 + || token === 35 || isLiteralPropertyName(); } function nextTokenIsClassOrFunction() { nextToken(); - return token === 69 /* ClassKeyword */ || token === 83 /* FunctionKeyword */; + return token === 69 || token === 83; } - // True if positioned at the start of a list element function isListElement(parsingContext, inErrorRecovery) { var node = currentNode(parsingContext); if (node) { return true; } switch (parsingContext) { - case 0 /* SourceElements */: - case 1 /* ModuleElements */: + case 0: + case 1: return isSourceElement(inErrorRecovery); - case 2 /* BlockStatements */: - case 4 /* SwitchClauseStatements */: + case 2: + case 4: return isStartOfStatement(inErrorRecovery); - case 3 /* SwitchClauses */: - return token === 67 /* CaseKeyword */ || token === 73 /* DefaultKeyword */; - case 5 /* TypeMembers */: + case 3: + return token === 67 || token === 73; + case 5: return isStartOfTypeMember(); - case 6 /* ClassMembers */: - // We allow semicolons as class elements (as specified by ES6) as long as we're - // not in error recovery. If we're in error recovery, we don't want an errant - // semicolon to be treated as a class member (since they're almost always used - // for statements. - return lookAhead(isClassMemberStart) || (token === 22 /* SemicolonToken */ && !inErrorRecovery); - case 7 /* EnumMembers */: - // Include open bracket computed properties. This technically also lets in indexers, - // which would be a candidate for improved error reporting. - return token === 18 /* OpenBracketToken */ || isLiteralPropertyName(); - case 13 /* ObjectLiteralMembers */: - return token === 18 /* OpenBracketToken */ || token === 35 /* AsteriskToken */ || isLiteralPropertyName(); - case 10 /* ObjectBindingElements */: + case 6: + return lookAhead(isClassMemberStart) || (token === 22 && !inErrorRecovery); + case 7: + return token === 18 || isLiteralPropertyName(); + case 13: + return token === 18 || token === 35 || isLiteralPropertyName(); + case 10: return isLiteralPropertyName(); - case 8 /* HeritageClauseElement */: - // If we see { } then only consume it as an expression if it is followed by , or { - // That way we won't consume the body of a class in its heritage clause. - if (token === 14 /* OpenBraceToken */) { + case 8: + if (token === 14) { return lookAhead(isValidHeritageClauseObjectLiteral); } if (!inErrorRecovery) { return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword(); } else { - // If we're in error recovery we tighten up what we're willing to match. - // That way we don't treat something like "this" as a valid heritage clause - // element during recovery. return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword(); } - case 9 /* VariableDeclarations */: + case 9: return isIdentifierOrPattern(); - case 11 /* ArrayBindingElements */: - return token === 23 /* CommaToken */ || token === 21 /* DotDotDotToken */ || isIdentifierOrPattern(); - case 16 /* TypeParameters */: + case 11: + return token === 23 || token === 21 || isIdentifierOrPattern(); + case 16: return isIdentifier(); - case 12 /* ArgumentExpressions */: - case 14 /* ArrayLiteralMembers */: - return token === 23 /* CommaToken */ || token === 21 /* DotDotDotToken */ || isStartOfExpression(); - case 15 /* Parameters */: + case 12: + case 14: + return token === 23 || token === 21 || isStartOfExpression(); + case 15: return isStartOfParameter(); - case 17 /* TypeArguments */: - case 18 /* TupleElementTypes */: - return token === 23 /* CommaToken */ || isStartOfType(); - case 19 /* HeritageClauses */: + case 17: + case 18: + return token === 23 || isStartOfType(); + case 19: return isHeritageClause(); - case 20 /* ImportOrExportSpecifiers */: + case 20: return isIdentifierOrKeyword(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); } function isValidHeritageClauseObjectLiteral() { - ts.Debug.assert(token === 14 /* OpenBraceToken */); - if (nextToken() === 15 /* CloseBraceToken */) { - // if we see "extends {}" then only treat the {} as what we're extending (and not - // the class body) if we have: - // - // extends {} { - // extends {}, - // extends {} extends - // extends {} implements + ts.Debug.assert(token === 14); + if (nextToken() === 15) { var next = nextToken(); - return next === 23 /* CommaToken */ || next === 14 /* OpenBraceToken */ || next === 79 /* ExtendsKeyword */ || next === 102 /* ImplementsKeyword */; + return next === 23 || next === 14 || next === 79 || next === 102; } return true; } @@ -6754,8 +5469,8 @@ var ts; return isIdentifier(); } function isHeritageClauseExtendsOrImplementsKeyword() { - if (token === 102 /* ImplementsKeyword */ || - token === 79 /* ExtendsKeyword */) { + if (token === 102 || + token === 79) { return lookAhead(nextTokenIsStartOfExpression); } return false; @@ -6764,73 +5479,57 @@ var ts; nextToken(); return isStartOfExpression(); } - // True if positioned at a list terminator function isListTerminator(kind) { - if (token === 1 /* EndOfFileToken */) { - // Being at the end of the file ends all lists. + if (token === 1) { return true; } switch (kind) { - case 1 /* ModuleElements */: - case 2 /* BlockStatements */: - case 3 /* SwitchClauses */: - case 5 /* TypeMembers */: - case 6 /* ClassMembers */: - case 7 /* EnumMembers */: - case 13 /* ObjectLiteralMembers */: - case 10 /* ObjectBindingElements */: - case 20 /* ImportOrExportSpecifiers */: - return token === 15 /* CloseBraceToken */; - case 4 /* SwitchClauseStatements */: - return token === 15 /* CloseBraceToken */ || token === 67 /* CaseKeyword */ || token === 73 /* DefaultKeyword */; - case 8 /* HeritageClauseElement */: - return token === 14 /* OpenBraceToken */ || token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; - case 9 /* VariableDeclarations */: + case 1: + case 2: + case 3: + case 5: + case 6: + case 7: + case 13: + case 10: + case 20: + return token === 15; + case 4: + return token === 15 || token === 67 || token === 73; + case 8: + return token === 14 || token === 79 || token === 102; + case 9: return isVariableDeclaratorListTerminator(); - case 16 /* TypeParameters */: - // Tokens other than '>' are here for better error recovery - return token === 25 /* GreaterThanToken */ || token === 16 /* OpenParenToken */ || token === 14 /* OpenBraceToken */ || token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; - case 12 /* ArgumentExpressions */: - // Tokens other than ')' are here for better error recovery - return token === 17 /* CloseParenToken */ || token === 22 /* SemicolonToken */; - case 14 /* ArrayLiteralMembers */: - case 18 /* TupleElementTypes */: - case 11 /* ArrayBindingElements */: - return token === 19 /* CloseBracketToken */; - case 15 /* Parameters */: - // Tokens other than ')' and ']' (the latter for index signatures) are here for better error recovery - return token === 17 /* CloseParenToken */ || token === 19 /* CloseBracketToken */ /*|| token === SyntaxKind.OpenBraceToken*/; - case 17 /* TypeArguments */: - // Tokens other than '>' are here for better error recovery - return token === 25 /* GreaterThanToken */ || token === 16 /* OpenParenToken */; - case 19 /* HeritageClauses */: - return token === 14 /* OpenBraceToken */ || token === 15 /* CloseBraceToken */; + case 16: + return token === 25 || token === 16 || token === 14 || token === 79 || token === 102; + case 12: + return token === 17 || token === 22; + case 14: + case 18: + case 11: + return token === 19; + case 15: + return token === 17 || token === 19; + case 17: + return token === 25 || token === 16; + case 19: + return token === 14 || token === 15; } } function isVariableDeclaratorListTerminator() { - // If we can consume a semicolon (either explicitly, or with ASI), then consider us done - // with parsing the list of variable declarators. if (canParseSemicolon()) { return true; } - // in the case where we're parsing the variable declarator of a 'for-in' statement, we - // are done if we see an 'in' keyword in front of us. Same with for-of if (isInOrOfKeyword(token)) { return true; } - // ERROR RECOVERY TWEAK: - // For better error recovery, if we see an '=>' then we just stop immediately. We've got an - // arrow function here and it's going to be very unlikely that we'll resynchronize and get - // another variable declaration. - if (token === 32 /* EqualsGreaterThanToken */) { + if (token === 32) { return true; } - // Keep trying to parse out variable declarators. return false; } - // True if positioned at element or terminator of the current list or any enclosing list function isInSomeParsingContext() { - for (var kind = 0; kind < 21 /* Count */; kind++) { + for (var kind = 0; kind < 21; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -6839,7 +5538,6 @@ var ts; } return false; } - // Parses a list of elements function parseList(kind, checkForStrictMode, parseElement) { var saveParsingContext = parsingContext; parsingContext |= 1 << kind; @@ -6850,7 +5548,6 @@ var ts; if (isListElement(kind, false)) { var element = parseListElement(kind, parseElement); result.push(element); - // test elements only if we are not already in strict mode if (checkForStrictMode && !inStrictModeContext()) { if (ts.isPrologueDirective(element)) { if (isUseStrictPrologueDirective(sourceFile, element)) { @@ -6873,12 +5570,9 @@ var ts; parsingContext = saveParsingContext; return result; } - /// Should be called only on prologue directives (isPrologueDirective(node) should be true) function isUseStrictPrologueDirective(sourceFile, node) { ts.Debug.assert(ts.isPrologueDirective(node)); var nodeText = ts.getSourceTextOfNodeFromSourceFile(sourceFile, node.expression); - // Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the - // string to contain unicode escapes (as per ES5). return nodeText === '"use strict"' || nodeText === "'use strict'"; } function parseListElement(parsingContext, parseElement) { @@ -6889,130 +5583,76 @@ var ts; return parseElement(); } function currentNode(parsingContext) { - // If there is an outstanding parse error that we've encountered, but not attached to - // some node, then we cannot get a node from the old source tree. This is because we - // want to mark the next node we encounter as being unusable. - // - // Note: This may be too conservative. Perhaps we could reuse the node and set the bit - // on it (or its leftmost child) as having the error. For now though, being conservative - // is nice and likely won't ever affect perf. if (parseErrorBeforeNextFinishedNode) { return undefined; } if (!syntaxCursor) { - // if we don't have a cursor, we could never return a node from the old tree. return undefined; } var node = syntaxCursor.currentNode(scanner.getStartPos()); - // Can't reuse a missing node. if (ts.nodeIsMissing(node)) { return undefined; } - // Can't reuse a node that intersected the change range. if (node.intersectsChange) { return undefined; } - // Can't reuse a node that contains a parse error. This is necessary so that we - // produce the same set of errors again. if (ts.containsParseError(node)) { return undefined; } - // We can only reuse a node if it was parsed under the same strict mode that we're - // currently in. i.e. if we originally parsed a node in non-strict mode, but then - // the user added 'using strict' at the top of the file, then we can't use that node - // again as the presense of strict mode may cause us to parse the tokens in the file - // differetly. - // - // Note: we *can* reuse tokens when the strict mode changes. That's because tokens - // are unaffected by strict mode. It's just the parser will decide what to do with it - // differently depending on what mode it is in. - // - // This also applies to all our other context flags as well. - var nodeContextFlags = node.parserContextFlags & 63 /* ParserGeneratedFlags */; + var nodeContextFlags = node.parserContextFlags & 63; if (nodeContextFlags !== contextFlags) { return undefined; } - // Ok, we have a node that looks like it could be reused. Now verify that it is valid - // in the currest list parsing context that we're currently at. if (!canReuseNode(node, parsingContext)) { return undefined; } return node; } function consumeNode(node) { - // Move the scanner so it is after the node we just consumed. scanner.setTextPos(node.end); nextToken(); return node; } function canReuseNode(node, parsingContext) { switch (parsingContext) { - case 1 /* ModuleElements */: + case 1: return isReusableModuleElement(node); - case 6 /* ClassMembers */: + case 6: return isReusableClassMember(node); - case 3 /* SwitchClauses */: + case 3: return isReusableSwitchClause(node); - case 2 /* BlockStatements */: - case 4 /* SwitchClauseStatements */: + case 2: + case 4: return isReusableStatement(node); - case 7 /* EnumMembers */: + case 7: return isReusableEnumMember(node); - case 5 /* TypeMembers */: + case 5: return isReusableTypeMember(node); - case 9 /* VariableDeclarations */: + case 9: return isReusableVariableDeclaration(node); - case 15 /* Parameters */: + case 15: return isReusableParameter(node); - // Any other lists we do not care about reusing nodes in. But feel free to add if - // you can do so safely. Danger areas involve nodes that may involve speculative - // parsing. If speculative parsing is involved with the node, then the range the - // parser reached while looking ahead might be in the edited range (see the example - // in canReuseVariableDeclaratorNode for a good case of this). - case 19 /* HeritageClauses */: - // This would probably be safe to reuse. There is no speculative parsing with - // heritage clauses. - case 16 /* TypeParameters */: - // This would probably be safe to reuse. There is no speculative parsing with - // type parameters. Note that that's because type *parameters* only occur in - // unambiguous *type* contexts. While type *arguments* occur in very ambiguous - // *expression* contexts. - case 18 /* TupleElementTypes */: - // This would probably be safe to reuse. There is no speculative parsing with - // tuple types. - // Technically, type argument list types are probably safe to reuse. While - // speculative parsing is involved with them (since type argument lists are only - // produced from speculative parsing a < as a type argument list), we only have - // the types because speculative parsing succeeded. Thus, the lookahead never - // went past the end of the list and rewound. - case 17 /* TypeArguments */: - // Note: these are almost certainly not safe to ever reuse. Expressions commonly - // need a large amount of lookahead, and we should not reuse them as they may - // have actually intersected the edit. - case 12 /* ArgumentExpressions */: - // This is not safe to reuse for the same reason as the 'AssignmentExpression' - // cases. i.e. a property assignment may end with an expression, and thus might - // have lookahead far beyond it's old node. - case 13 /* ObjectLiteralMembers */: - // This is probably not safe to reuse. There can be speculative parsing with - // type names in a heritage clause. There can be generic names in the type - // name list, and there can be left hand side expressions (which can have type - // arguments.) - case 8 /* HeritageClauseElement */: + case 19: + case 16: + case 18: + case 17: + case 12: + case 13: + case 8: } return false; } function isReusableModuleElement(node) { if (node) { switch (node.kind) { - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 216 /* ExportDeclaration */: - case 215 /* ExportAssignment */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: + case 210: + case 209: + case 216: + case 215: + case 202: + case 203: + case 206: + case 205: return true; } return isReusableStatement(node); @@ -7022,13 +5662,13 @@ var ts; function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 136 /* Constructor */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 133 /* PropertyDeclaration */: - case 179 /* SemicolonClassElement */: + case 136: + case 141: + case 135: + case 137: + case 138: + case 133: + case 179: return true; } } @@ -7037,8 +5677,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 221: + case 222: return true; } } @@ -7047,77 +5687,61 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 181 /* VariableStatement */: - case 180 /* Block */: - case 184 /* IfStatement */: - case 183 /* ExpressionStatement */: - case 196 /* ThrowStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 182 /* EmptyStatement */: - case 197 /* TryStatement */: - case 195 /* LabeledStatement */: - case 185 /* DoStatement */: - case 198 /* DebuggerStatement */: + case 201: + case 181: + case 180: + case 184: + case 183: + case 196: + case 192: + case 194: + case 191: + case 190: + case 188: + case 189: + case 187: + case 186: + case 193: + case 182: + case 197: + case 195: + case 185: + case 198: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 227 /* EnumMember */; + return node.kind === 227; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 140 /* ConstructSignature */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: - case 132 /* PropertySignature */: - case 139 /* CallSignature */: + case 140: + case 134: + case 141: + case 132: + case 139: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 199 /* VariableDeclaration */) { + if (node.kind !== 199) { return false; } - // Very subtle incremental parsing bug. Consider the following code: - // - // let v = new List < A, B - // - // This is actually legal code. It's a list of variable declarators "v = new List() - // - // then we have a problem. "v = new List= 0) { - // Always preserve a trailing comma by marking it on the NodeArray result.hasTrailingComma = true; } result.end = getNodeEnd(); @@ -7218,11 +5828,10 @@ var ts; } return createMissingList(); } - // The allowReservedWords parameter controls whether reserved words are permitted after the first dot function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); - while (parseOptional(20 /* DotToken */)) { - var node = createNode(127 /* QualifiedName */, entity.pos); + while (parseOptional(20)) { + var node = createNode(127, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -7230,59 +5839,37 @@ var ts; return entity; } function parseRightSideOfDot(allowIdentifierNames) { - // Technically a keyword is valid here as all keywords are identifier names. - // However, often we'll encounter this in error situations when the keyword - // is actually starting another valid construct. - // - // So, we check for the following specific case: - // - // name. - // keyword identifierNameOrKeyword - // - // Note: the newlines are important here. For example, if that above code - // were rewritten into: - // - // name.keyword - // identifierNameOrKeyword - // - // Then we would consider it valid. That's because ASI would take effect and - // the code would be implicitly: "name.keyword; identifierNameOrKeyword". - // In the first case though, ASI will not take effect because there is not a - // line terminator after the keyword. if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord()) { var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); if (matchesPattern) { - // Report that we need an identifier. However, report it right after the dot, - // and not on the next token. This is because the next token might actually - // be an identifier and the error woudl be quite confusing. - return createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Identifier_expected); + return createMissingNode(65, true, ts.Diagnostics.Identifier_expected); } } return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(172 /* TemplateExpression */); + var template = createNode(172); template.head = parseLiteralNode(); - ts.Debug.assert(template.head.kind === 11 /* TemplateHead */, "Template head has wrong token kind"); + ts.Debug.assert(template.head.kind === 11, "Template head has wrong token kind"); var templateSpans = []; templateSpans.pos = getNodePos(); do { templateSpans.push(parseTemplateSpan()); - } while (templateSpans[templateSpans.length - 1].literal.kind === 12 /* TemplateMiddle */); + } while (ts.lastOrUndefined(templateSpans).literal.kind === 12); templateSpans.end = getNodeEnd(); template.templateSpans = templateSpans; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(178 /* TemplateSpan */); + var span = createNode(178); span.expression = allowInAnd(parseExpression); var literal; - if (token === 15 /* CloseBraceToken */) { + if (token === 15) { reScanTemplateToken(); literal = parseLiteralNode(); } else { - literal = parseExpectedToken(13 /* TemplateTail */, false, ts.Diagnostics._0_expected, ts.tokenToString(15 /* CloseBraceToken */)); + literal = parseExpectedToken(13, false, ts.Diagnostics._0_expected, ts.tokenToString(15)); } span.literal = literal; return finishNode(span); @@ -7300,73 +5887,55 @@ var ts; var tokenPos = scanner.getTokenPos(); nextToken(); finishNode(node); - // Octal literals are not allowed in strict mode or ES5 - // Note that theoretically the following condition would hold true literals like 009, - // which is not octal.But because of how the scanner separates the tokens, we would - // never get a token like this. Instead, we would get 00 and 9 as two separate tokens. - // We also do not need to check for negatives because any prefix operator would be part of a - // parent unary expression. - if (node.kind === 7 /* NumericLiteral */ - && sourceText.charCodeAt(tokenPos) === 48 /* _0 */ + if (node.kind === 7 + && sourceText.charCodeAt(tokenPos) === 48 && ts.isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) { - node.flags |= 16384 /* OctalLiteral */; + node.flags |= 16384; } return node; } - // TYPES function parseTypeReference() { - var node = createNode(142 /* TypeReference */); + var node = createNode(142); node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); - if (!scanner.hasPrecedingLineBreak() && token === 24 /* LessThanToken */) { - node.typeArguments = parseBracketedList(17 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + if (!scanner.hasPrecedingLineBreak() && token === 24) { + node.typeArguments = parseBracketedList(17, parseType, 24, 25); } return finishNode(node); } function parseTypeQuery() { - var node = createNode(145 /* TypeQuery */); - parseExpected(97 /* TypeOfKeyword */); + var node = createNode(145); + parseExpected(97); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(129 /* TypeParameter */); + var node = createNode(129); node.name = parseIdentifier(); - if (parseOptional(79 /* ExtendsKeyword */)) { - // It's not uncommon for people to write improper constraints to a generic. If the - // user writes a constraint that is an expression and not an actual type, then parse - // it out as an expression (so we can recover well), but report that a type is needed - // instead. + if (parseOptional(79)) { if (isStartOfType() || !isStartOfExpression()) { node.constraint = parseType(); } else { - // It was not a type, and it looked like an expression. Parse out an expression - // here so we recover well. Note: it is important that we call parseUnaryExpression - // and not parseExpression here. If the user has: - // - // - // - // We do *not* want to consume the > as we're consuming the expression for "". node.expression = parseUnaryExpressionOrHigher(); } } return finishNode(node); } function parseTypeParameters() { - if (token === 24 /* LessThanToken */) { - return parseBracketedList(16 /* TypeParameters */, parseTypeParameter, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + if (token === 24) { + return parseBracketedList(16, parseTypeParameter, 24, 25); } } function parseParameterType() { - if (parseOptional(51 /* ColonToken */)) { - return token === 8 /* StringLiteral */ + if (parseOptional(51)) { + return token === 8 ? parseLiteralNode(true) : parseType(); } return undefined; } function isStartOfParameter() { - return token === 21 /* DotDotDotToken */ || isIdentifierOrPattern() || ts.isModifier(token) || token === 52 /* AtToken */; + return token === 21 || isIdentifierOrPattern() || ts.isModifier(token) || token === 52; } function setModifiers(node, modifiers) { if (modifiers) { @@ -7375,43 +5944,24 @@ var ts; } } function parseParameter() { - var node = createNode(130 /* Parameter */); + var node = createNode(130); node.decorators = parseDecorators(); setModifiers(node, parseModifiers()); - node.dotDotDotToken = parseOptionalToken(21 /* DotDotDotToken */); - // SingleNameBinding[Yield,GeneratorParameter] : See 13.2.3 - // [+GeneratorParameter]BindingIdentifier[Yield]Initializer[In]opt - // [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt + node.dotDotDotToken = parseOptionalToken(21); node.name = inGeneratorParameterContext() ? doInYieldContext(parseIdentifierOrPattern) : parseIdentifierOrPattern(); if (ts.getFullWidth(node.name) === 0 && node.flags === 0 && ts.isModifier(token)) { - // in cases like - // 'use strict' - // function foo(static) - // isParameter('static') === true, because of isModifier('static') - // however 'static' is not a legal identifier in a strict mode. - // so result of this function will be ParameterDeclaration (flags = 0, name = missing, type = undefined, initializer = undefined) - // and current token will not change => parsing of the enclosing parameter list will last till the end of time (or OOM) - // to avoid this we'll advance cursor to the next token. nextToken(); } - node.questionToken = parseOptionalToken(50 /* QuestionToken */); + node.questionToken = parseOptionalToken(50); node.type = parseParameterType(); node.initializer = inGeneratorParameterContext() ? doOutsideOfYieldContext(parseParameterInitializer) : parseParameterInitializer(); - // Do not check for initializers in an ambient context for parameters. This is not - // a grammar error because the grammar allows arbitrary call signatures in - // an ambient context. - // It is actually not necessary for this to be an error at all. The reason is that - // function/constructor implementations are syntactically disallowed in ambient - // contexts. In addition, parameter initializers are semantically disallowed in - // overload signatures. So parameter initializers are transitively disallowed in - // ambient contexts. return finishNode(node); } function parseParameterInitializer() { return parseInitializer(true); } function fillSignature(returnToken, yieldAndGeneratorParameterContext, requireCompleteParameterList, signature) { - var returnTokenRequired = returnToken === 32 /* EqualsGreaterThanToken */; + var returnTokenRequired = returnToken === 32; signature.typeParameters = parseTypeParameters(); signature.parameters = parseParameterList(yieldAndGeneratorParameterContext, requireCompleteParameterList); if (returnTokenRequired) { @@ -7422,88 +5972,46 @@ var ts; signature.type = parseType(); } } - // Note: after careful analysis of the grammar, it does not appear to be possible to - // have 'Yield' And 'GeneratorParameter' not in sync. i.e. any production calling - // this FormalParameters production either always sets both to true, or always sets - // both to false. As such we only have a single parameter to represent both. function parseParameterList(yieldAndGeneratorParameterContext, requireCompleteParameterList) { - // FormalParameters[Yield,GeneratorParameter] : - // ... - // - // FormalParameter[Yield,GeneratorParameter] : - // BindingElement[?Yield, ?GeneratorParameter] - // - // BindingElement[Yield, GeneratorParameter ] : See 13.2.3 - // SingleNameBinding[?Yield, ?GeneratorParameter] - // [+GeneratorParameter]BindingPattern[?Yield, GeneratorParameter]Initializer[In]opt - // [~GeneratorParameter]BindingPattern[?Yield]Initializer[In, ?Yield]opt - // - // SingleNameBinding[Yield, GeneratorParameter] : See 13.2.3 - // [+GeneratorParameter]BindingIdentifier[Yield]Initializer[In]opt - // [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt - if (parseExpected(16 /* OpenParenToken */)) { + if (parseExpected(16)) { var savedYieldContext = inYieldContext(); var savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(yieldAndGeneratorParameterContext); setGeneratorParameterContext(yieldAndGeneratorParameterContext); - var result = parseDelimitedList(15 /* Parameters */, parseParameter); + var result = parseDelimitedList(15, parseParameter); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); - if (!parseExpected(17 /* CloseParenToken */) && requireCompleteParameterList) { - // Caller insisted that we had to end with a ) We didn't. So just return - // undefined here. + if (!parseExpected(17) && requireCompleteParameterList) { return undefined; } return result; } - // We didn't even have an open paren. If the caller requires a complete parameter list, - // we definitely can't provide that. However, if they're ok with an incomplete one, - // then just return an empty set of parameters. return requireCompleteParameterList ? undefined : createMissingList(); } function parseTypeMemberSemicolon() { - // We allow type members to be separated by commas or (possibly ASI) semicolons. - // First check if it was a comma. If so, we're done with the member. - if (parseOptional(23 /* CommaToken */)) { + if (parseOptional(23)) { return; } - // Didn't have a comma. We must have a (possible ASI) semicolon. parseSemicolon(); } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 140 /* ConstructSignature */) { - parseExpected(88 /* NewKeyword */); + if (kind === 140) { + parseExpected(88); } - fillSignature(51 /* ColonToken */, false, false, node); + fillSignature(51, false, false, node); parseTypeMemberSemicolon(); return finishNode(node); } function isIndexSignature() { - if (token !== 18 /* OpenBracketToken */) { + if (token !== 18) { return false; } return lookAhead(isUnambiguouslyIndexSignature); } function isUnambiguouslyIndexSignature() { - // The only allowed sequence is: - // - // [id: - // - // However, for error recovery, we also check the following cases: - // - // [... - // [id, - // [id?, - // [id?: - // [id?] - // [public id - // [private id - // [protected id - // [] - // nextToken(); - if (token === 21 /* DotDotDotToken */ || token === 19 /* CloseBracketToken */) { + if (token === 21 || token === 19) { return true; } if (ts.isModifier(token)) { @@ -7516,30 +6024,22 @@ var ts; return false; } else { - // Skip the identifier nextToken(); } - // A colon signifies a well formed indexer - // A comma should be a badly formed indexer because comma expressions are not allowed - // in computed properties. - if (token === 51 /* ColonToken */ || token === 23 /* CommaToken */) { + if (token === 51 || token === 23) { return true; } - // Question mark could be an indexer with an optional property, - // or it could be a conditional expression in a computed property. - if (token !== 50 /* QuestionToken */) { + if (token !== 50) { return false; } - // If any of the following tokens are after the question mark, it cannot - // be a conditional expression, so treat it as an indexer. nextToken(); - return token === 51 /* ColonToken */ || token === 23 /* CommaToken */ || token === 19 /* CloseBracketToken */; + return token === 51 || token === 23 || token === 19; } function parseIndexSignatureDeclaration(fullStart, decorators, modifiers) { - var node = createNode(141 /* IndexSignature */, fullStart); + var node = createNode(141, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - node.parameters = parseBracketedList(15 /* Parameters */, parseParameter, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); + node.parameters = parseBracketedList(15, parseParameter, 18, 19); node.type = parseTypeAnnotation(); parseTypeMemberSemicolon(); return finishNode(node); @@ -7547,19 +6047,17 @@ var ts; function parsePropertyOrMethodSignature() { var fullStart = scanner.getStartPos(); var name = parsePropertyName(); - var questionToken = parseOptionalToken(50 /* QuestionToken */); - if (token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */) { - var method = createNode(134 /* MethodSignature */, fullStart); + var questionToken = parseOptionalToken(50); + if (token === 16 || token === 24) { + var method = createNode(134, fullStart); method.name = name; method.questionToken = questionToken; - // Method signatues don't exist in expression contexts. So they have neither - // [Yield] nor [GeneratorParameter] - fillSignature(51 /* ColonToken */, false, false, method); + fillSignature(51, false, false, method); parseTypeMemberSemicolon(); return finishNode(method); } else { - var property = createNode(132 /* PropertySignature */, fullStart); + var property = createNode(132, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -7569,9 +6067,9 @@ var ts; } function isStartOfTypeMember() { switch (token) { - case 16 /* OpenParenToken */: - case 24 /* LessThanToken */: - case 18 /* OpenBracketToken */: + case 16: + case 24: + case 18: return true; default: if (ts.isModifier(token)) { @@ -7591,37 +6089,29 @@ var ts; } function isTypeMemberWithLiteralPropertyName() { nextToken(); - return token === 16 /* OpenParenToken */ || - token === 24 /* LessThanToken */ || - token === 50 /* QuestionToken */ || - token === 51 /* ColonToken */ || + return token === 16 || + token === 24 || + token === 50 || + token === 51 || canParseSemicolon(); } function parseTypeMember() { switch (token) { - case 16 /* OpenParenToken */: - case 24 /* LessThanToken */: - return parseSignatureMember(139 /* CallSignature */); - case 18 /* OpenBracketToken */: - // Indexer or computed property + case 16: + case 24: + return parseSignatureMember(139); + case 18: return isIndexSignature() ? parseIndexSignatureDeclaration(scanner.getStartPos(), undefined, undefined) : parsePropertyOrMethodSignature(); - case 88 /* NewKeyword */: + case 88: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(140 /* ConstructSignature */); + return parseSignatureMember(140); } - // fall through. - case 8 /* StringLiteral */: - case 7 /* NumericLiteral */: + case 8: + case 7: return parsePropertyOrMethodSignature(); default: - // Index declaration as allowed as a type member. But as per the grammar, - // they also allow modifiers. So we have to check for an index declaration - // that might be following modifiers. This ensures that things work properly - // when incrementally parsing as the parser will produce the Index declaration - // if it has the same text regardless of whether it is inside a class or an - // object type. if (ts.isModifier(token)) { var result = tryParse(parseIndexSignatureWithModifiers); if (result) { @@ -7643,18 +6133,18 @@ var ts; } function isStartOfConstructSignature() { nextToken(); - return token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */; + return token === 16 || token === 24; } function parseTypeLiteral() { - var node = createNode(146 /* TypeLiteral */); + var node = createNode(146); node.members = parseObjectTypeMembers(); return finishNode(node); } function parseObjectTypeMembers() { var members; - if (parseExpected(14 /* OpenBraceToken */)) { - members = parseList(5 /* TypeMembers */, false, parseTypeMember); - parseExpected(15 /* CloseBraceToken */); + if (parseExpected(14)) { + members = parseList(5, false, parseTypeMember); + parseExpected(15); } else { members = createMissingList(); @@ -7662,48 +6152,47 @@ var ts; return members; } function parseTupleType() { - var node = createNode(148 /* TupleType */); - node.elementTypes = parseBracketedList(18 /* TupleElementTypes */, parseType, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); + var node = createNode(148); + node.elementTypes = parseBracketedList(18, parseType, 18, 19); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(150 /* ParenthesizedType */); - parseExpected(16 /* OpenParenToken */); + var node = createNode(150); + parseExpected(16); node.type = parseType(); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); return finishNode(node); } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 144 /* ConstructorType */) { - parseExpected(88 /* NewKeyword */); + if (kind === 144) { + parseExpected(88); } - fillSignature(32 /* EqualsGreaterThanToken */, false, false, node); + fillSignature(32, false, false, node); return finishNode(node); } function parseKeywordAndNoDot() { var node = parseTokenNode(); - return token === 20 /* DotToken */ ? undefined : node; + return token === 20 ? undefined : node; } function parseNonArrayType() { switch (token) { - case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: - case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: - // If these are followed by a dot, then parse these out as a dotted type reference instead. + case 112: + case 122: + case 120: + case 113: + case 123: var node = tryParse(parseKeywordAndNoDot); return node || parseTypeReference(); - case 99 /* VoidKeyword */: + case 99: return parseTokenNode(); - case 97 /* TypeOfKeyword */: + case 97: return parseTypeQuery(); - case 14 /* OpenBraceToken */: + case 14: return parseTypeLiteral(); - case 18 /* OpenBracketToken */: + case 18: return parseTupleType(); - case 16 /* OpenParenToken */: + case 16: return parseParenthesizedType(); default: return parseTypeReference(); @@ -7711,21 +6200,19 @@ var ts; } function isStartOfType() { switch (token) { - case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: - case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: - case 99 /* VoidKeyword */: - case 97 /* TypeOfKeyword */: - case 14 /* OpenBraceToken */: - case 18 /* OpenBracketToken */: - case 24 /* LessThanToken */: - case 88 /* NewKeyword */: + case 112: + case 122: + case 120: + case 113: + case 123: + case 99: + case 97: + case 14: + case 18: + case 24: + case 88: return true; - case 16 /* OpenParenToken */: - // Only consider '(' the start of a type if followed by ')', '...', an identifier, a modifier, - // or something that starts a type. We don't want to consider things like '(1)' a type. + case 16: return lookAhead(isStartOfParenthesizedOrFunctionType); default: return isIdentifier(); @@ -7733,13 +6220,13 @@ var ts; } function isStartOfParenthesizedOrFunctionType() { nextToken(); - return token === 17 /* CloseParenToken */ || isStartOfParameter() || isStartOfType(); + return token === 17 || isStartOfParameter() || isStartOfType(); } function parseArrayTypeOrHigher() { var type = parseNonArrayType(); - while (!scanner.hasPrecedingLineBreak() && parseOptional(18 /* OpenBracketToken */)) { - parseExpected(19 /* CloseBracketToken */); - var node = createNode(147 /* ArrayType */, type.pos); + while (!scanner.hasPrecedingLineBreak() && parseOptional(18)) { + parseExpected(19); + var node = createNode(147, type.pos); node.elementType = type; type = finishNode(node); } @@ -7747,48 +6234,40 @@ var ts; } function parseUnionTypeOrHigher() { var type = parseArrayTypeOrHigher(); - if (token === 44 /* BarToken */) { + if (token === 44) { var types = [type]; types.pos = type.pos; - while (parseOptional(44 /* BarToken */)) { + while (parseOptional(44)) { types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(149 /* UnionType */, type.pos); + var node = createNode(149, type.pos); node.types = types; type = finishNode(node); } return type; } function isStartOfFunctionType() { - if (token === 24 /* LessThanToken */) { + if (token === 24) { return true; } - return token === 16 /* OpenParenToken */ && lookAhead(isUnambiguouslyStartOfFunctionType); + return token === 16 && lookAhead(isUnambiguouslyStartOfFunctionType); } function isUnambiguouslyStartOfFunctionType() { nextToken(); - if (token === 17 /* CloseParenToken */ || token === 21 /* DotDotDotToken */) { - // ( ) - // ( ... + if (token === 17 || token === 21) { return true; } if (isIdentifier() || ts.isModifier(token)) { nextToken(); - if (token === 51 /* ColonToken */ || token === 23 /* CommaToken */ || - token === 50 /* QuestionToken */ || token === 53 /* EqualsToken */ || + if (token === 51 || token === 23 || + token === 50 || token === 53 || isIdentifier() || ts.isModifier(token)) { - // ( id : - // ( id , - // ( id ? - // ( id = - // ( modifier id return true; } - if (token === 17 /* CloseParenToken */) { + if (token === 17) { nextToken(); - if (token === 32 /* EqualsGreaterThanToken */) { - // ( id ) => + if (token === 32) { return true; } } @@ -7796,8 +6275,6 @@ var ts; return false; } function parseType() { - // The rules about 'yield' only apply to actual code/expression contexts. They don't - // apply to 'type' contexts. So we disable these parameters here before moving on. var savedYieldContext = inYieldContext(); var savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(false); @@ -7809,37 +6286,36 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(143 /* FunctionType */); + return parseFunctionOrConstructorType(143); } - if (token === 88 /* NewKeyword */) { - return parseFunctionOrConstructorType(144 /* ConstructorType */); + if (token === 88) { + return parseFunctionOrConstructorType(144); } return parseUnionTypeOrHigher(); } function parseTypeAnnotation() { - return parseOptional(51 /* ColonToken */) ? parseType() : undefined; + return parseOptional(51) ? parseType() : undefined; } - // EXPRESSIONS function isStartOfLeftHandSideExpression() { switch (token) { - case 93 /* ThisKeyword */: - case 91 /* SuperKeyword */: - case 89 /* NullKeyword */: - case 95 /* TrueKeyword */: - case 80 /* FalseKeyword */: - case 7 /* NumericLiteral */: - case 8 /* StringLiteral */: - case 10 /* NoSubstitutionTemplateLiteral */: - case 11 /* TemplateHead */: - case 16 /* OpenParenToken */: - case 18 /* OpenBracketToken */: - case 14 /* OpenBraceToken */: - case 83 /* FunctionKeyword */: - case 69 /* ClassKeyword */: - case 88 /* NewKeyword */: - case 36 /* SlashToken */: - case 57 /* SlashEqualsToken */: - case 65 /* Identifier */: + case 93: + case 91: + case 89: + case 95: + case 80: + case 7: + case 8: + case 10: + case 11: + case 16: + case 18: + case 14: + case 83: + case 69: + case 88: + case 36: + case 57: + case 65: return true; default: return isIdentifier(); @@ -7850,26 +6326,19 @@ var ts; return true; } switch (token) { - case 33 /* PlusToken */: - case 34 /* MinusToken */: - case 47 /* TildeToken */: - case 46 /* ExclamationToken */: - case 74 /* DeleteKeyword */: - case 97 /* TypeOfKeyword */: - case 99 /* VoidKeyword */: - case 38 /* PlusPlusToken */: - case 39 /* MinusMinusToken */: - case 24 /* LessThanToken */: - case 110 /* YieldKeyword */: - // Yield always starts an expression. Either it is an identifier (in which case - // it is definitely an expression). Or it's a keyword (either because we're in - // a generator, or in strict mode (or both)) and it started a yield expression. + case 33: + case 34: + case 47: + case 46: + case 74: + case 97: + case 99: + case 38: + case 39: + case 24: + case 110: return true; default: - // Error tolerance. If we see the start of some binary operator, we consider - // that the start of an expression. That way we'll parse out a missing identifier, - // give a good message about an identifier being missing, and then consume the - // rest of the binary expression. if (isBinaryOperator()) { return true; } @@ -7877,25 +6346,23 @@ var ts; } } function isStartOfExpressionStatement() { - // As per the grammar, none of '{' or 'function' or 'class' can start an expression statement. - return token !== 14 /* OpenBraceToken */ && - token !== 83 /* FunctionKeyword */ && - token !== 69 /* ClassKeyword */ && - token !== 52 /* AtToken */ && + return token !== 14 && + token !== 83 && + token !== 69 && + token !== 52 && isStartOfExpression(); } function parseExpression() { // Expression[in]: // AssignmentExpression[in] // Expression[in] , AssignmentExpression[in] - // clear the decorator context when parsing Expression, as it should be unambiguous when parsing a decorator var saveDecoratorContext = inDecoratorContext(); if (saveDecoratorContext) { setDecoratorContext(false); } var expr = parseAssignmentExpressionOrHigher(); var operatorToken; - while ((operatorToken = parseOptionalToken(23 /* CommaToken */))) { + while ((operatorToken = parseOptionalToken(23))) { expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher()); } if (saveDecoratorContext) { @@ -7904,24 +6371,12 @@ var ts; return expr; } function parseInitializer(inParameter) { - if (token !== 53 /* EqualsToken */) { - // It's not uncommon during typing for the user to miss writing the '=' token. Check if - // there is no newline after the last token and if we're on an expression. If so, parse - // this as an equals-value clause with a missing equals. - // NOTE: There are two places where we allow equals-value clauses. The first is in a - // variable declarator. The second is with a parameter. For variable declarators - // it's more likely that a { would be a allowed (as an object literal). While this - // is also allowed for parameters, the risk is that we consume the { as an object - // literal when it really will be for the block following the parameter. - if (scanner.hasPrecedingLineBreak() || (inParameter && token === 14 /* OpenBraceToken */) || !isStartOfExpression()) { - // preceding line break, open brace in a parameter (likely a function body) or current token is not an expression - - // do not try to parse initializer + if (token !== 53) { + if (scanner.hasPrecedingLineBreak() || (inParameter && token === 14) || !isStartOfExpression()) { return undefined; } } - // Initializer[In, Yield] : - // = AssignmentExpression[?In, ?Yield] - parseExpected(53 /* EqualsToken */); + parseExpected(53); return parseAssignmentExpressionOrHigher(); } function parseAssignmentExpressionOrHigher() { @@ -7934,72 +6389,30 @@ var ts; // // Note: for ease of implementation we treat productions '2' and '3' as the same thing. // (i.e. they're both BinaryExpressions with an assignment operator in it). - // First, do the simple check if we have a YieldExpression (production '5'). if (isYieldExpression()) { return parseYieldExpression(); } - // Then, check if we have an arrow function (production '4') that starts with a parenthesized - // parameter list. If we do, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is - // not a LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done - // with AssignmentExpression if we see one. var arrowExpression = tryParseParenthesizedArrowFunctionExpression(); if (arrowExpression) { return arrowExpression; } - // Now try to see if we're in production '1', '2' or '3'. A conditional expression can - // start with a LogicalOrExpression, while the assignment productions can only start with - // LeftHandSideExpressions. - // - // So, first, we try to just parse out a BinaryExpression. If we get something that is a - // LeftHandSide or higher, then we can try to parse out the assignment expression part. - // Otherwise, we try to parse out the conditional expression bit. We want to allow any - // binary expression here, so we pass in the 'lowest' precedence here so that it matches - // and consumes anything. var expr = parseBinaryExpressionOrHigher(0); - // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized - // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single - // identifier and the current token is an arrow. - if (expr.kind === 65 /* Identifier */ && token === 32 /* EqualsGreaterThanToken */) { + if (expr.kind === 65 && token === 32) { return parseSimpleArrowFunctionExpression(expr); } - // Now see if we might be in cases '2' or '3'. - // If the expression was a LHS expression, and we have an assignment operator, then - // we're in '2' or '3'. Consume the assignment and return. - // - // Note: we call reScanGreaterToken so that we get an appropriately merged token - // for cases like > > = becoming >>= if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) { return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher()); } - // It wasn't an assignment or a lambda. This is a conditional expression: return parseConditionalExpressionRest(expr); } function isYieldExpression() { - if (token === 110 /* YieldKeyword */) { - // If we have a 'yield' keyword, and htis is a context where yield expressions are - // allowed, then definitely parse out a yield expression. + if (token === 110) { if (inYieldContext()) { return true; } if (inStrictModeContext()) { - // If we're in strict mode, then 'yield' is a keyword, could only ever start - // a yield expression. return true; } - // We're in a context where 'yield expr' is not allowed. However, if we can - // definitely tell that the user was trying to parse a 'yield expr' and not - // just a normal expr that start with a 'yield' identifier, then parse out - // a 'yield expr'. We can then report an error later that they are only - // allowed in generator expressions. - // - // for example, if we see 'yield(foo)', then we'll have to treat that as an - // invocation expression of something called 'yield'. However, if we have - // 'yield foo' then that is not legal as a normal expression, so we can - // definitely recognize this as a yield expression. - // - // for now we just check if the next token is an identifier. More heuristics - // can be added here later as necessary. We just need to make sure that we - // don't accidently consume something legal. return lookAhead(nextTokenIsIdentifierOnSameLine); } return false; @@ -8011,214 +6424,134 @@ var ts; function nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() { nextToken(); return !scanner.hasPrecedingLineBreak() && - (isIdentifier() || token === 14 /* OpenBraceToken */ || token === 18 /* OpenBracketToken */); + (isIdentifier() || token === 14 || token === 18); } function parseYieldExpression() { - var node = createNode(173 /* YieldExpression */); - // YieldExpression[In] : - // yield - // yield [no LineTerminator here] [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield] - // yield [no LineTerminator here] * [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield] + var node = createNode(173); nextToken(); if (!scanner.hasPrecedingLineBreak() && - (token === 35 /* AsteriskToken */ || isStartOfExpression())) { - node.asteriskToken = parseOptionalToken(35 /* AsteriskToken */); + (token === 35 || isStartOfExpression())) { + node.asteriskToken = parseOptionalToken(35); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } else { - // if the next token is not on the same line as yield. or we don't have an '*' or - // the start of an expressin, then this is just a simple "yield" expression. return finishNode(node); } } function parseSimpleArrowFunctionExpression(identifier) { - ts.Debug.assert(token === 32 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(164 /* ArrowFunction */, identifier.pos); - var parameter = createNode(130 /* Parameter */, identifier.pos); + ts.Debug.assert(token === 32, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); + var node = createNode(164, identifier.pos); + var parameter = createNode(130, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; node.parameters.pos = parameter.pos; node.parameters.end = parameter.end; - node.equalsGreaterThanToken = parseExpectedToken(32 /* EqualsGreaterThanToken */, false, ts.Diagnostics._0_expected, "=>"); + node.equalsGreaterThanToken = parseExpectedToken(32, false, ts.Diagnostics._0_expected, "=>"); node.body = parseArrowFunctionExpressionBody(); return finishNode(node); } function tryParseParenthesizedArrowFunctionExpression() { var triState = isParenthesizedArrowFunctionExpression(); - if (triState === 0 /* False */) { - // It's definitely not a parenthesized arrow function expression. + if (triState === 0) { return undefined; } - // If we definitely have an arrow function, then we can just parse one, not requiring a - // following => or { token. Otherwise, we *might* have an arrow function. Try to parse - // it out, but don't allow any ambiguity, and return 'undefined' if this could be an - // expression instead. - var arrowFunction = triState === 1 /* True */ + var arrowFunction = triState === 1 ? parseParenthesizedArrowFunctionExpressionHead(true) : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead); if (!arrowFunction) { - // Didn't appear to actually be a parenthesized arrow function. Just bail out. return undefined; } - // If we have an arrow, then try to parse the body. Even if not, try to parse if we - // have an opening brace, just in case we're in an error state. var lastToken = token; - arrowFunction.equalsGreaterThanToken = parseExpectedToken(32 /* EqualsGreaterThanToken */, false, ts.Diagnostics._0_expected, "=>"); - arrowFunction.body = (lastToken === 32 /* EqualsGreaterThanToken */ || lastToken === 14 /* OpenBraceToken */) + arrowFunction.equalsGreaterThanToken = parseExpectedToken(32, false, ts.Diagnostics._0_expected, "=>"); + arrowFunction.body = (lastToken === 32 || lastToken === 14) ? parseArrowFunctionExpressionBody() : parseIdentifier(); return finishNode(arrowFunction); } - // True -> We definitely expect a parenthesized arrow function here. - // False -> There *cannot* be a parenthesized arrow function here. - // Unknown -> There *might* be a parenthesized arrow function here. - // Speculatively look ahead to be sure, and rollback if not. function isParenthesizedArrowFunctionExpression() { - if (token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */) { + if (token === 16 || token === 24) { return lookAhead(isParenthesizedArrowFunctionExpressionWorker); } - if (token === 32 /* EqualsGreaterThanToken */) { - // ERROR RECOVERY TWEAK: - // If we see a standalone => try to parse it as an arrow function expression as that's - // likely what the user intended to write. - return 1 /* True */; + if (token === 32) { + return 1; } - // Definitely not a parenthesized arrow function. - return 0 /* False */; + return 0; } function isParenthesizedArrowFunctionExpressionWorker() { var first = token; var second = nextToken(); - if (first === 16 /* OpenParenToken */) { - if (second === 17 /* CloseParenToken */) { - // Simple cases: "() =>", "(): ", and "() {". - // This is an arrow function with no parameters. - // The last one is not actually an arrow function, - // but this is probably what the user intended. + if (first === 16) { + if (second === 17) { var third = nextToken(); switch (third) { - case 32 /* EqualsGreaterThanToken */: - case 51 /* ColonToken */: - case 14 /* OpenBraceToken */: - return 1 /* True */; + case 32: + case 51: + case 14: + return 1; default: - return 0 /* False */; - } - } - // If encounter "([" or "({", this could be the start of a binding pattern. - // Examples: - // ([ x ]) => { } - // ({ x }) => { } - // ([ x ]) - // ({ x }) - if (second === 18 /* OpenBracketToken */ || second === 14 /* OpenBraceToken */) { - return 2 /* Unknown */; - } - // Simple case: "(..." - // This is an arrow function with a rest parameter. - if (second === 21 /* DotDotDotToken */) { - return 1 /* True */; - } - // If we had "(" followed by something that's not an identifier, - // then this definitely doesn't look like a lambda. - // Note: we could be a little more lenient and allow - // "(public" or "(private". These would not ever actually be allowed, - // but we could provide a good error message instead of bailing out. + return 0; + } + } + if (second === 18 || second === 14) { + return 2; + } + if (second === 21) { + return 1; + } if (!isIdentifier()) { - return 0 /* False */; + return 0; } - // If we have something like "(a:", then we must have a - // type-annotated parameter in an arrow function expression. - if (nextToken() === 51 /* ColonToken */) { - return 1 /* True */; + if (nextToken() === 51) { + return 1; } - // This *could* be a parenthesized arrow function. - // Return Unknown to let the caller know. - return 2 /* Unknown */; + return 2; } else { - ts.Debug.assert(first === 24 /* LessThanToken */); - // If we have "<" not followed by an identifier, - // then this definitely is not an arrow function. + ts.Debug.assert(first === 24); if (!isIdentifier()) { - return 0 /* False */; + return 0; } - // This *could* be a parenthesized arrow function. - return 2 /* Unknown */; + return 2; } } function parsePossibleParenthesizedArrowFunctionExpressionHead() { return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(164 /* ArrowFunction */); - // Arrow functions are never generators. - // - // If we're speculatively parsing a signature for a parenthesized arrow function, then - // we have to have a complete parameter list. Otherwise we might see something like - // a => (b => c) - // And think that "(b =>" was actually a parenthesized arrow function with a missing - // close paren. - fillSignature(51 /* ColonToken */, false, !allowAmbiguity, node); - // If we couldn't get parameters, we definitely could not parse out an arrow function. + var node = createNode(164); + fillSignature(51, false, !allowAmbiguity, node); if (!node.parameters) { return undefined; } - // Parsing a signature isn't enough. - // Parenthesized arrow signatures often look like other valid expressions. - // For instance: - // - "(x = 10)" is an assignment expression parsed as a signature with a default parameter value. - // - "(x,y)" is a comma expression parsed as a signature with two parameters. - // - "a ? (b): c" will have "(b):" parsed as a signature with a return type annotation. - // - // So we need just a bit of lookahead to ensure that it can only be a signature. - if (!allowAmbiguity && token !== 32 /* EqualsGreaterThanToken */ && token !== 14 /* OpenBraceToken */) { - // Returning undefined here will cause our caller to rewind to where we started from. + if (!allowAmbiguity && token !== 32 && token !== 14) { return undefined; } return node; } function parseArrowFunctionExpressionBody() { - if (token === 14 /* OpenBraceToken */) { + if (token === 14) { return parseFunctionBlock(false, false); } if (isStartOfStatement(true) && !isStartOfExpressionStatement() && - token !== 83 /* FunctionKeyword */ && - token !== 69 /* ClassKeyword */) { - // Check if we got a plain statement (i.e. no expression-statements, no function/class expressions/declarations) - // - // Here we try to recover from a potential error situation in the case where the - // user meant to supply a block. For example, if the user wrote: - // - // a => - // let v = 0; - // } - // - // they may be missing an open brace. Check to see if that's the case so we can - // try to recover better. If we don't do this, then the next close curly we see may end - // up preemptively closing the containing construct. - // - // Note: even when 'ignoreMissingOpenBrace' is passed as true, parseBody will still error. + token !== 83 && + token !== 69) { return parseFunctionBlock(false, true); } return parseAssignmentExpressionOrHigher(); } function parseConditionalExpressionRest(leftOperand) { - // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher. - var questionToken = parseOptionalToken(50 /* QuestionToken */); + var questionToken = parseOptionalToken(50); if (!questionToken) { return leftOperand; } - // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and - // we do not that for the 'whenFalse' part. - var node = createNode(171 /* ConditionalExpression */, leftOperand.pos); + var node = createNode(171, leftOperand.pos); node.condition = leftOperand; node.questionToken = questionToken; node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher); - node.colonToken = parseExpectedToken(51 /* ColonToken */, false, ts.Diagnostics._0_expected, ts.tokenToString(51 /* ColonToken */)); + node.colonToken = parseExpectedToken(51, false, ts.Diagnostics._0_expected, ts.tokenToString(51)); node.whenFalse = parseAssignmentExpressionOrHigher(); return finishNode(node); } @@ -8227,19 +6560,16 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 86 /* InKeyword */ || t === 126 /* OfKeyword */; + return t === 86 || t === 126; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { - // We either have a binary operator here, or we're finished. We call - // reScanGreaterToken so that we merge token sequences like > and = into >= reScanGreaterToken(); var newPrecedence = getBinaryOperatorPrecedence(); - // Check the precedence to see if we should "take" this operator if (newPrecedence <= precedence) { break; } - if (token === 86 /* InKeyword */ && inDisallowInContext()) { + if (token === 86 && inDisallowInContext()) { break; } leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence)); @@ -8247,99 +6577,97 @@ var ts; return leftOperand; } function isBinaryOperator() { - if (inDisallowInContext() && token === 86 /* InKeyword */) { + if (inDisallowInContext() && token === 86) { return false; } return getBinaryOperatorPrecedence() > 0; } function getBinaryOperatorPrecedence() { switch (token) { - case 49 /* BarBarToken */: + case 49: return 1; - case 48 /* AmpersandAmpersandToken */: + case 48: return 2; - case 44 /* BarToken */: + case 44: return 3; - case 45 /* CaretToken */: + case 45: return 4; - case 43 /* AmpersandToken */: + case 43: return 5; - case 28 /* EqualsEqualsToken */: - case 29 /* ExclamationEqualsToken */: - case 30 /* EqualsEqualsEqualsToken */: - case 31 /* ExclamationEqualsEqualsToken */: + case 28: + case 29: + case 30: + case 31: return 6; - case 24 /* LessThanToken */: - case 25 /* GreaterThanToken */: - case 26 /* LessThanEqualsToken */: - case 27 /* GreaterThanEqualsToken */: - case 87 /* InstanceOfKeyword */: - case 86 /* InKeyword */: + case 24: + case 25: + case 26: + case 27: + case 87: + case 86: return 7; - case 40 /* LessThanLessThanToken */: - case 41 /* GreaterThanGreaterThanToken */: - case 42 /* GreaterThanGreaterThanGreaterThanToken */: + case 40: + case 41: + case 42: return 8; - case 33 /* PlusToken */: - case 34 /* MinusToken */: + case 33: + case 34: return 9; - case 35 /* AsteriskToken */: - case 36 /* SlashToken */: - case 37 /* PercentToken */: + case 35: + case 36: + case 37: return 10; } - // -1 is lower than all other precedences. Returning it will cause binary expression - // parsing to stop. return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(170 /* BinaryExpression */, left.pos); + var node = createNode(170, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(168 /* PrefixUnaryExpression */); + var node = createNode(168); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(165 /* DeleteExpression */); + var node = createNode(165); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(166 /* TypeOfExpression */); + var node = createNode(166); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(167 /* VoidExpression */); + var node = createNode(167); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseUnaryExpressionOrHigher() { switch (token) { - case 33 /* PlusToken */: - case 34 /* MinusToken */: - case 47 /* TildeToken */: - case 46 /* ExclamationToken */: - case 38 /* PlusPlusToken */: - case 39 /* MinusMinusToken */: + case 33: + case 34: + case 47: + case 46: + case 38: + case 39: return parsePrefixUnaryExpression(); - case 74 /* DeleteKeyword */: + case 74: return parseDeleteExpression(); - case 97 /* TypeOfKeyword */: + case 97: return parseTypeOfExpression(); - case 99 /* VoidKeyword */: + case 99: return parseVoidExpression(); - case 24 /* LessThanToken */: + case 24: return parseTypeAssertion(); default: return parsePostfixExpressionOrHigher(); @@ -8348,8 +6676,8 @@ var ts; function parsePostfixExpressionOrHigher() { var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(ts.isLeftHandSideExpression(expression)); - if ((token === 38 /* PlusPlusToken */ || token === 39 /* MinusMinusToken */) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(169 /* PostfixUnaryExpression */, expression.pos); + if ((token === 38 || token === 39) && !scanner.hasPrecedingLineBreak()) { + var node = createNode(169, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -8358,147 +6686,63 @@ var ts; return expression; } function parseLeftHandSideExpressionOrHigher() { - // Original Ecma: - // LeftHandSideExpression: See 11.2 - // NewExpression - // CallExpression - // - // Our simplification: - // - // LeftHandSideExpression: See 11.2 - // MemberExpression - // CallExpression - // - // See comment in parseMemberExpressionOrHigher on how we replaced NewExpression with - // MemberExpression to make our lives easier. - // - // to best understand the below code, it's important to see how CallExpression expands - // out into its own productions: - // - // CallExpression: - // MemberExpression Arguments - // CallExpression Arguments - // CallExpression[Expression] - // CallExpression.IdentifierName - // super ( ArgumentListopt ) - // super.IdentifierName - // - // Because of the recursion in these calls, we need to bottom out first. There are two - // bottom out states we can run into. Either we see 'super' which must start either of - // the last two CallExpression productions. Or we have a MemberExpression which either - // completes the LeftHandSideExpression, or starts the beginning of the first four - // CallExpression productions. - var expression = token === 91 /* SuperKeyword */ + var expression = token === 91 ? parseSuperExpression() : parseMemberExpressionOrHigher(); - // Now, we *may* be complete. However, we might have consumed the start of a - // CallExpression. As such, we need to consume the rest of it here to be complete. return parseCallExpressionRest(expression); } function parseMemberExpressionOrHigher() { - // Note: to make our lives simpler, we decompose the the NewExpression productions and - // place ObjectCreationExpression and FunctionExpression into PrimaryExpression. - // like so: - // - // PrimaryExpression : See 11.1 - // this - // Identifier - // Literal - // ArrayLiteral - // ObjectLiteral - // (Expression) - // FunctionExpression - // new MemberExpression Arguments? - // - // MemberExpression : See 11.2 - // PrimaryExpression - // MemberExpression[Expression] - // MemberExpression.IdentifierName - // - // CallExpression : See 11.2 - // MemberExpression - // CallExpression Arguments - // CallExpression[Expression] - // CallExpression.IdentifierName - // - // Technically this is ambiguous. i.e. CallExpression defines: - // - // CallExpression: - // CallExpression Arguments - // - // If you see: "new Foo()" - // - // Then that could be treated as a single ObjectCreationExpression, or it could be - // treated as the invocation of "new Foo". We disambiguate that in code (to match - // the original grammar) by making sure that if we see an ObjectCreationExpression - // we always consume arguments if they are there. So we treat "new Foo()" as an - // object creation only, and not at all as an invocation) Another way to think - // about this is that for every "new" that we see, we will consume an argument list if - // it is there as part of the *associated* object creation node. Any additional - // argument lists we see, will become invocation expressions. - // - // Because there are no other places in the grammar now that refer to FunctionExpression - // or ObjectCreationExpression, it is safe to push down into the PrimaryExpression - // production. - // - // Because CallExpression and MemberExpression are left recursive, we need to bottom out - // of the recursion immediately. So we parse out a primary expression to start with. var expression = parsePrimaryExpression(); return parseMemberExpressionRest(expression); } function parseSuperExpression() { var expression = parseTokenNode(); - if (token === 16 /* OpenParenToken */ || token === 20 /* DotToken */) { + if (token === 16 || token === 20) { return expression; } - // If we have seen "super" it must be followed by '(' or '.'. - // If it wasn't then just try to parse out a '.' and report an error. - var node = createNode(156 /* PropertyAccessExpression */, expression.pos); + var node = createNode(156, expression.pos); node.expression = expression; - node.dotToken = parseExpectedToken(20 /* DotToken */, false, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); + node.dotToken = parseExpectedToken(20, false, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); node.name = parseRightSideOfDot(true); return finishNode(node); } function parseTypeAssertion() { - var node = createNode(161 /* TypeAssertionExpression */); - parseExpected(24 /* LessThanToken */); + var node = createNode(161); + parseExpected(24); node.type = parseType(); - parseExpected(25 /* GreaterThanToken */); + parseExpected(25); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseMemberExpressionRest(expression) { while (true) { - var dotToken = parseOptionalToken(20 /* DotToken */); + var dotToken = parseOptionalToken(20); if (dotToken) { - var propertyAccess = createNode(156 /* PropertyAccessExpression */, expression.pos); + var propertyAccess = createNode(156, expression.pos); propertyAccess.expression = expression; propertyAccess.dotToken = dotToken; propertyAccess.name = parseRightSideOfDot(true); expression = finishNode(propertyAccess); continue; } - // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName - if (!inDecoratorContext() && parseOptional(18 /* OpenBracketToken */)) { - var indexedAccess = createNode(157 /* ElementAccessExpression */, expression.pos); + if (!inDecoratorContext() && parseOptional(18)) { + var indexedAccess = createNode(157, expression.pos); indexedAccess.expression = expression; - // It's not uncommon for a user to write: "new Type[]". - // Check for that common pattern and report a better error message. - if (token !== 19 /* CloseBracketToken */) { + if (token !== 19) { indexedAccess.argumentExpression = allowInAnd(parseExpression); - if (indexedAccess.argumentExpression.kind === 8 /* StringLiteral */ || indexedAccess.argumentExpression.kind === 7 /* NumericLiteral */) { + if (indexedAccess.argumentExpression.kind === 8 || indexedAccess.argumentExpression.kind === 7) { var literal = indexedAccess.argumentExpression; literal.text = internIdentifier(literal.text); } } - parseExpected(19 /* CloseBracketToken */); + parseExpected(19); expression = finishNode(indexedAccess); continue; } - if (token === 10 /* NoSubstitutionTemplateLiteral */ || token === 11 /* TemplateHead */) { - var tagExpression = createNode(160 /* TaggedTemplateExpression */, expression.pos); + if (token === 10 || token === 11) { + var tagExpression = createNode(160, expression.pos); tagExpression.tag = expression; - tagExpression.template = token === 10 /* NoSubstitutionTemplateLiteral */ + tagExpression.template = token === 10 ? parseLiteralNode() : parseTemplateExpression(); expression = finishNode(tagExpression); @@ -8510,24 +6754,20 @@ var ts; function parseCallExpressionRest(expression) { while (true) { expression = parseMemberExpressionRest(expression); - if (token === 24 /* LessThanToken */) { - // See if this is the start of a generic invocation. If so, consume it and - // keep checking for postfix expressions. Otherwise, it's just a '<' that's - // part of an arithmetic expression. Break out so we consume it higher in the - // stack. + if (token === 24) { var typeArguments = tryParse(parseTypeArgumentsInExpression); if (!typeArguments) { return expression; } - var callExpr = createNode(158 /* CallExpression */, expression.pos); + var callExpr = createNode(158, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); continue; } - else if (token === 16 /* OpenParenToken */) { - var callExpr = createNode(158 /* CallExpression */, expression.pos); + else if (token === 16) { + var callExpr = createNode(158, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -8537,133 +6777,121 @@ var ts; } } function parseArgumentList() { - parseExpected(16 /* OpenParenToken */); - var result = parseDelimitedList(12 /* ArgumentExpressions */, parseArgumentExpression); - parseExpected(17 /* CloseParenToken */); + parseExpected(16); + var result = parseDelimitedList(12, parseArgumentExpression); + parseExpected(17); return result; } function parseTypeArgumentsInExpression() { - if (!parseOptional(24 /* LessThanToken */)) { + if (!parseOptional(24)) { return undefined; } - var typeArguments = parseDelimitedList(17 /* TypeArguments */, parseType); - if (!parseExpected(25 /* GreaterThanToken */)) { - // If it doesn't have the closing > then it's definitely not an type argument list. + var typeArguments = parseDelimitedList(17, parseType); + if (!parseExpected(25)) { return undefined; } - // If we have a '<', then only parse this as a arugment list if the type arguments - // are complete and we have an open paren. if we don't, rewind and return nothing. return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined; } function canFollowTypeArgumentsInExpression() { switch (token) { - case 16 /* OpenParenToken */: // foo( - // this case are the only case where this token can legally follow a type argument - // list. So we definitely want to treat this as a type arg list. - case 20 /* DotToken */: // foo. - case 17 /* CloseParenToken */: // foo) - case 19 /* CloseBracketToken */: // foo] - case 51 /* ColonToken */: // foo: - case 22 /* SemicolonToken */: // foo; - case 50 /* QuestionToken */: // foo? - case 28 /* EqualsEqualsToken */: // foo == - case 30 /* EqualsEqualsEqualsToken */: // foo === - case 29 /* ExclamationEqualsToken */: // foo != - case 31 /* ExclamationEqualsEqualsToken */: // foo !== - case 48 /* AmpersandAmpersandToken */: // foo && - case 49 /* BarBarToken */: // foo || - case 45 /* CaretToken */: // foo ^ - case 43 /* AmpersandToken */: // foo & - case 44 /* BarToken */: // foo | - case 15 /* CloseBraceToken */: // foo } - case 1 /* EndOfFileToken */: - // these cases can't legally follow a type arg list. However, they're not legal - // expressions either. The user is probably in the middle of a generic type. So - // treat it as such. + case 16: + case 20: + case 17: + case 19: + case 51: + case 22: + case 50: + case 28: + case 30: + case 29: + case 31: + case 48: + case 49: + case 45: + case 43: + case 44: + case 15: + case 1: return true; - case 23 /* CommaToken */: // foo, - case 14 /* OpenBraceToken */: // foo { - // We don't want to treat these as type arguments. Otherwise we'll parse this - // as an invocation expression. Instead, we want to parse out the expression - // in isolation from the type arguments. + case 23: + case 14: default: - // Anything else treat as an expression. return false; } } function parsePrimaryExpression() { switch (token) { - case 7 /* NumericLiteral */: - case 8 /* StringLiteral */: - case 10 /* NoSubstitutionTemplateLiteral */: + case 7: + case 8: + case 10: return parseLiteralNode(); - case 93 /* ThisKeyword */: - case 91 /* SuperKeyword */: - case 89 /* NullKeyword */: - case 95 /* TrueKeyword */: - case 80 /* FalseKeyword */: + case 93: + case 91: + case 89: + case 95: + case 80: return parseTokenNode(); - case 16 /* OpenParenToken */: + case 16: return parseParenthesizedExpression(); - case 18 /* OpenBracketToken */: + case 18: return parseArrayLiteralExpression(); - case 14 /* OpenBraceToken */: + case 14: return parseObjectLiteralExpression(); - case 69 /* ClassKeyword */: + case 69: return parseClassExpression(); - case 83 /* FunctionKeyword */: + case 83: return parseFunctionExpression(); - case 88 /* NewKeyword */: + case 88: return parseNewExpression(); - case 36 /* SlashToken */: - case 57 /* SlashEqualsToken */: - if (reScanSlashToken() === 9 /* RegularExpressionLiteral */) { + case 36: + case 57: + if (reScanSlashToken() === 9) { return parseLiteralNode(); } break; - case 11 /* TemplateHead */: + case 11: return parseTemplateExpression(); } return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(162 /* ParenthesizedExpression */); - parseExpected(16 /* OpenParenToken */); + var node = createNode(162); + parseExpected(16); node.expression = allowInAnd(parseExpression); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); return finishNode(node); } function parseSpreadElement() { - var node = createNode(174 /* SpreadElementExpression */); - parseExpected(21 /* DotDotDotToken */); + var node = createNode(174); + parseExpected(21); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { - return token === 21 /* DotDotDotToken */ ? parseSpreadElement() : - token === 23 /* CommaToken */ ? createNode(176 /* OmittedExpression */) : + return token === 21 ? parseSpreadElement() : + token === 23 ? createNode(176) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(154 /* ArrayLiteralExpression */); - parseExpected(18 /* OpenBracketToken */); + var node = createNode(154); + parseExpected(18); if (scanner.hasPrecedingLineBreak()) - node.flags |= 512 /* MultiLine */; - node.elements = parseDelimitedList(14 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement); - parseExpected(19 /* CloseBracketToken */); + node.flags |= 512; + node.elements = parseDelimitedList(14, parseArgumentOrArrayLiteralElement); + parseExpected(19); return finishNode(node); } function tryParseAccessorDeclaration(fullStart, decorators, modifiers) { - if (parseContextualModifier(116 /* GetKeyword */)) { - return parseAccessorDeclaration(137 /* GetAccessor */, fullStart, decorators, modifiers); + if (parseContextualModifier(116)) { + return parseAccessorDeclaration(137, fullStart, decorators, modifiers); } - else if (parseContextualModifier(121 /* SetKeyword */)) { - return parseAccessorDeclaration(138 /* SetAccessor */, fullStart, decorators, modifiers); + else if (parseContextualModifier(121)) { + return parseAccessorDeclaration(138, fullStart, decorators, modifiers); } return undefined; } @@ -8675,55 +6903,49 @@ var ts; if (accessor) { return accessor; } - var asteriskToken = parseOptionalToken(35 /* AsteriskToken */); + var asteriskToken = parseOptionalToken(35); var tokenIsIdentifier = isIdentifier(); var nameToken = token; var propertyName = parsePropertyName(); - // Disallowing of optional property assignments happens in the grammar checker. - var questionToken = parseOptionalToken(50 /* QuestionToken */); - if (asteriskToken || token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */) { + var questionToken = parseOptionalToken(50); + if (asteriskToken || token === 16 || token === 24) { return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken); } - // Parse to check if it is short-hand property assignment or normal property assignment - if ((token === 23 /* CommaToken */ || token === 15 /* CloseBraceToken */) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(226 /* ShorthandPropertyAssignment */, fullStart); + if ((token === 23 || token === 15) && tokenIsIdentifier) { + var shorthandDeclaration = createNode(226, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(225 /* PropertyAssignment */, fullStart); + var propertyAssignment = createNode(225, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; - parseExpected(51 /* ColonToken */); + parseExpected(51); propertyAssignment.initializer = allowInAnd(parseAssignmentExpressionOrHigher); return finishNode(propertyAssignment); } } function parseObjectLiteralExpression() { - var node = createNode(155 /* ObjectLiteralExpression */); - parseExpected(14 /* OpenBraceToken */); + var node = createNode(155); + parseExpected(14); if (scanner.hasPrecedingLineBreak()) { - node.flags |= 512 /* MultiLine */; + node.flags |= 512; } - node.properties = parseDelimitedList(13 /* ObjectLiteralMembers */, parseObjectLiteralElement, true); - parseExpected(15 /* CloseBraceToken */); + node.properties = parseDelimitedList(13, parseObjectLiteralElement, true); + parseExpected(15); return finishNode(node); } function parseFunctionExpression() { - // GeneratorExpression : - // function * BindingIdentifier[Yield]opt (FormalParameters[Yield, GeneratorParameter]) { GeneratorBody[Yield] } - // FunctionExpression: - // function BindingIdentifieropt(FormalParameters) { FunctionBody } var saveDecoratorContext = inDecoratorContext(); if (saveDecoratorContext) { setDecoratorContext(false); } - var node = createNode(163 /* FunctionExpression */); - parseExpected(83 /* FunctionKeyword */); - node.asteriskToken = parseOptionalToken(35 /* AsteriskToken */); + var node = createNode(163); + parseExpected(83); + node.asteriskToken = parseOptionalToken(35); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); - fillSignature(51 /* ColonToken */, !!node.asteriskToken, false, node); + fillSignature(51, !!node.asteriskToken, false, node); node.body = parseFunctionBlock(!!node.asteriskToken, false); if (saveDecoratorContext) { setDecoratorContext(true); @@ -8734,21 +6956,20 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(159 /* NewExpression */); - parseExpected(88 /* NewKeyword */); + var node = createNode(159); + parseExpected(88); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); - if (node.typeArguments || token === 16 /* OpenParenToken */) { + if (node.typeArguments || token === 16) { node.arguments = parseArgumentList(); } return finishNode(node); } - // STATEMENTS function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(180 /* Block */); - if (parseExpected(14 /* OpenBraceToken */, diagnosticMessage) || ignoreMissingOpenBrace) { - node.statements = parseList(2 /* BlockStatements */, checkForStrictMode, parseStatement); - parseExpected(15 /* CloseBraceToken */); + var node = createNode(180); + if (parseExpected(14, diagnosticMessage) || ignoreMissingOpenBrace) { + node.statements = parseList(2, checkForStrictMode, parseStatement); + parseExpected(15); } else { node.statements = createMissingList(); @@ -8758,8 +6979,6 @@ var ts; function parseFunctionBlock(allowYield, ignoreMissingOpenBrace, diagnosticMessage) { var savedYieldContext = inYieldContext(); setYieldContext(allowYield); - // We may be in a [Decorator] context when parsing a function expression or - // arrow function. The body of the function is not in [Decorator] context. var saveDecoratorContext = inDecoratorContext(); if (saveDecoratorContext) { setDecoratorContext(false); @@ -8772,51 +6991,47 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(182 /* EmptyStatement */); - parseExpected(22 /* SemicolonToken */); + var node = createNode(182); + parseExpected(22); return finishNode(node); } function parseIfStatement() { - var node = createNode(184 /* IfStatement */); - parseExpected(84 /* IfKeyword */); - parseExpected(16 /* OpenParenToken */); + var node = createNode(184); + parseExpected(84); + parseExpected(16); node.expression = allowInAnd(parseExpression); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); node.thenStatement = parseStatement(); - node.elseStatement = parseOptional(76 /* ElseKeyword */) ? parseStatement() : undefined; + node.elseStatement = parseOptional(76) ? parseStatement() : undefined; return finishNode(node); } function parseDoStatement() { - var node = createNode(185 /* DoStatement */); - parseExpected(75 /* DoKeyword */); + var node = createNode(185); + parseExpected(75); node.statement = parseStatement(); - parseExpected(100 /* WhileKeyword */); - parseExpected(16 /* OpenParenToken */); + parseExpected(100); + parseExpected(16); node.expression = allowInAnd(parseExpression); - parseExpected(17 /* CloseParenToken */); - // From: https://mail.mozilla.org/pipermail/es-discuss/2011-August/016188.html - // 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in - // spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby - // do;while(0)x will have a semicolon inserted before x. - parseOptional(22 /* SemicolonToken */); + parseExpected(17); + parseOptional(22); return finishNode(node); } function parseWhileStatement() { - var node = createNode(186 /* WhileStatement */); - parseExpected(100 /* WhileKeyword */); - parseExpected(16 /* OpenParenToken */); + var node = createNode(186); + parseExpected(100); + parseExpected(16); node.expression = allowInAnd(parseExpression); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); node.statement = parseStatement(); return finishNode(node); } function parseForOrForInOrForOfStatement() { var pos = getNodePos(); - parseExpected(82 /* ForKeyword */); - parseExpected(16 /* OpenParenToken */); + parseExpected(82); + parseExpected(16); var initializer = undefined; - if (token !== 22 /* SemicolonToken */) { - if (token === 98 /* VarKeyword */ || token === 104 /* LetKeyword */ || token === 70 /* ConstKeyword */) { + if (token !== 22) { + if (token === 98 || token === 104 || token === 70) { initializer = parseVariableDeclarationList(true); } else { @@ -8824,32 +7039,32 @@ var ts; } } var forOrForInOrForOfStatement; - if (parseOptional(86 /* InKeyword */)) { - var forInStatement = createNode(188 /* ForInStatement */, pos); + if (parseOptional(86)) { + var forInStatement = createNode(188, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(126 /* OfKeyword */)) { - var forOfStatement = createNode(189 /* ForOfStatement */, pos); + else if (parseOptional(126)) { + var forOfStatement = createNode(189, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(187 /* ForStatement */, pos); + var forStatement = createNode(187, pos); forStatement.initializer = initializer; - parseExpected(22 /* SemicolonToken */); - if (token !== 22 /* SemicolonToken */ && token !== 17 /* CloseParenToken */) { + parseExpected(22); + if (token !== 22 && token !== 17) { forStatement.condition = allowInAnd(parseExpression); } - parseExpected(22 /* SemicolonToken */); - if (token !== 17 /* CloseParenToken */) { + parseExpected(22); + if (token !== 17) { forStatement.incrementor = allowInAnd(parseExpression); } - parseExpected(17 /* CloseParenToken */); + parseExpected(17); forOrForInOrForOfStatement = forStatement; } forOrForInOrForOfStatement.statement = parseStatement(); @@ -8857,7 +7072,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 191 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */); + parseExpected(kind === 191 ? 66 : 71); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -8865,8 +7080,8 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(192 /* ReturnStatement */); - parseExpected(90 /* ReturnKeyword */); + var node = createNode(192); + parseExpected(90); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); } @@ -8874,115 +7089,98 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(193 /* WithStatement */); - parseExpected(101 /* WithKeyword */); - parseExpected(16 /* OpenParenToken */); + var node = createNode(193); + parseExpected(101); + parseExpected(16); node.expression = allowInAnd(parseExpression); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); node.statement = parseStatement(); return finishNode(node); } function parseCaseClause() { - var node = createNode(221 /* CaseClause */); - parseExpected(67 /* CaseKeyword */); + var node = createNode(221); + parseExpected(67); node.expression = allowInAnd(parseExpression); - parseExpected(51 /* ColonToken */); - node.statements = parseList(4 /* SwitchClauseStatements */, false, parseStatement); + parseExpected(51); + node.statements = parseList(4, false, parseStatement); return finishNode(node); } function parseDefaultClause() { - var node = createNode(222 /* DefaultClause */); - parseExpected(73 /* DefaultKeyword */); - parseExpected(51 /* ColonToken */); - node.statements = parseList(4 /* SwitchClauseStatements */, false, parseStatement); + var node = createNode(222); + parseExpected(73); + parseExpected(51); + node.statements = parseList(4, false, parseStatement); return finishNode(node); } function parseCaseOrDefaultClause() { - return token === 67 /* CaseKeyword */ ? parseCaseClause() : parseDefaultClause(); + return token === 67 ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(194 /* SwitchStatement */); - parseExpected(92 /* SwitchKeyword */); - parseExpected(16 /* OpenParenToken */); + var node = createNode(194); + parseExpected(92); + parseExpected(16); node.expression = allowInAnd(parseExpression); - parseExpected(17 /* CloseParenToken */); - var caseBlock = createNode(208 /* CaseBlock */, scanner.getStartPos()); - parseExpected(14 /* OpenBraceToken */); - caseBlock.clauses = parseList(3 /* SwitchClauses */, false, parseCaseOrDefaultClause); - parseExpected(15 /* CloseBraceToken */); + parseExpected(17); + var caseBlock = createNode(208, scanner.getStartPos()); + parseExpected(14); + caseBlock.clauses = parseList(3, false, parseCaseOrDefaultClause); + parseExpected(15); node.caseBlock = finishNode(caseBlock); return finishNode(node); } function parseThrowStatement() { // ThrowStatement[Yield] : // throw [no LineTerminator here]Expression[In, ?Yield]; - // Because of automatic semicolon insertion, we need to report error if this - // throw could be terminated with a semicolon. Note: we can't call 'parseExpression' - // directly as that might consume an expression on the following line. - // We just return 'undefined' in that case. The actual error will be reported in the - // grammar walker. - var node = createNode(196 /* ThrowStatement */); - parseExpected(94 /* ThrowKeyword */); + var node = createNode(196); + parseExpected(94); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); return finishNode(node); } - // TODO: Review for error recovery function parseTryStatement() { - var node = createNode(197 /* TryStatement */); - parseExpected(96 /* TryKeyword */); + var node = createNode(197); + parseExpected(96); node.tryBlock = parseBlock(false, false); - node.catchClause = token === 68 /* CatchKeyword */ ? parseCatchClause() : undefined; - // If we don't have a catch clause, then we must have a finally clause. Try to parse - // one out no matter what. - if (!node.catchClause || token === 81 /* FinallyKeyword */) { - parseExpected(81 /* FinallyKeyword */); + node.catchClause = token === 68 ? parseCatchClause() : undefined; + if (!node.catchClause || token === 81) { + parseExpected(81); node.finallyBlock = parseBlock(false, false); } return finishNode(node); } function parseCatchClause() { - var result = createNode(224 /* CatchClause */); - parseExpected(68 /* CatchKeyword */); - if (parseExpected(16 /* OpenParenToken */)) { + var result = createNode(224); + parseExpected(68); + if (parseExpected(16)) { result.variableDeclaration = parseVariableDeclaration(); } - parseExpected(17 /* CloseParenToken */); + parseExpected(17); result.block = parseBlock(false, false); return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(198 /* DebuggerStatement */); - parseExpected(72 /* DebuggerKeyword */); + var node = createNode(198); + parseExpected(72); parseSemicolon(); return finishNode(node); } function parseExpressionOrLabeledStatement() { - // Avoiding having to do the lookahead for a labeled statement by just trying to parse - // out an expression, seeing if it is identifier and then seeing if it is followed by - // a colon. var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); - if (expression.kind === 65 /* Identifier */ && parseOptional(51 /* ColonToken */)) { - var labeledStatement = createNode(195 /* LabeledStatement */, fullStart); + if (expression.kind === 65 && parseOptional(51)) { + var labeledStatement = createNode(195, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(183 /* ExpressionStatement */, fullStart); + var expressionStatement = createNode(183, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); } } function isStartOfStatement(inErrorRecovery) { - // Functions, variable statements and classes are allowed as a statement. But as per - // the grammar, they also allow modifiers. So we have to check for those statements - // that might be following modifiers.This ensures that things work properly when - // incrementally parsing as the parser will produce the same FunctionDeclaraiton, - // VariableStatement or ClassDeclaration, if it has the same text regardless of whether - // it is inside a block or not. if (ts.isModifier(token)) { var result = lookAhead(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers); if (result) { @@ -8990,58 +7188,43 @@ var ts; } } switch (token) { - case 22 /* SemicolonToken */: - // If we're in error recovery, then we don't want to treat ';' as an empty statement. - // The problem is that ';' can show up in far too many contexts, and if we see one - // and assume it's a statement, then we may bail out inappropriately from whatever - // we're parsing. For example, if we have a semicolon in the middle of a class, then - // we really don't want to assume the class is over and we're on a statement in the - // outer module. We just want to consume and move on. + case 22: return !inErrorRecovery; - case 14 /* OpenBraceToken */: - case 98 /* VarKeyword */: - case 104 /* LetKeyword */: - case 83 /* FunctionKeyword */: - case 69 /* ClassKeyword */: - case 84 /* IfKeyword */: - case 75 /* DoKeyword */: - case 100 /* WhileKeyword */: - case 82 /* ForKeyword */: - case 71 /* ContinueKeyword */: - case 66 /* BreakKeyword */: - case 90 /* ReturnKeyword */: - case 101 /* WithKeyword */: - case 92 /* SwitchKeyword */: - case 94 /* ThrowKeyword */: - case 96 /* TryKeyword */: - case 72 /* DebuggerKeyword */: - // 'catch' and 'finally' do not actually indicate that the code is part of a statement, - // however, we say they are here so that we may gracefully parse them and error later. - case 68 /* CatchKeyword */: - case 81 /* FinallyKeyword */: + case 14: + case 98: + case 104: + case 83: + case 69: + case 84: + case 75: + case 100: + case 82: + case 71: + case 66: + case 90: + case 101: + case 92: + case 94: + case 96: + case 72: + case 68: + case 81: return true; - case 70 /* ConstKeyword */: - // const keyword can precede enum keyword when defining constant enums - // 'const enum' do not start statement. - // In ES 6 'enum' is a future reserved keyword, so it should not be used as identifier + case 70: var isConstEnum = lookAhead(nextTokenIsEnumKeyword); return !isConstEnum; - case 103 /* InterfaceKeyword */: - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: - case 77 /* EnumKeyword */: - case 124 /* TypeKeyword */: - // When followed by an identifier, these do not start a statement but might - // instead be following declarations + case 103: + case 117: + case 118: + case 77: + case 124: if (isDeclarationStart()) { return false; } - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: - case 109 /* StaticKeyword */: - // When followed by an identifier or keyword, these do not start a statement but - // might instead be following type members + case 108: + case 106: + case 107: + case 109: if (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine)) { return false; } @@ -9051,7 +7234,7 @@ var ts; } function nextTokenIsEnumKeyword() { nextToken(); - return token === 77 /* EnumKeyword */; + return token === 77; } function nextTokenIsIdentifierOrKeywordOnSameLine() { nextToken(); @@ -9059,61 +7242,49 @@ var ts; } function parseStatement() { switch (token) { - case 14 /* OpenBraceToken */: + case 14: return parseBlock(false, false); - case 98 /* VarKeyword */: - case 70 /* ConstKeyword */: - // const here should always be parsed as const declaration because of check in 'isStatement' + case 98: + case 70: return parseVariableStatement(scanner.getStartPos(), undefined, undefined); - case 83 /* FunctionKeyword */: + case 83: return parseFunctionDeclaration(scanner.getStartPos(), undefined, undefined); - case 69 /* ClassKeyword */: + case 69: return parseClassDeclaration(scanner.getStartPos(), undefined, undefined); - case 22 /* SemicolonToken */: + case 22: return parseEmptyStatement(); - case 84 /* IfKeyword */: + case 84: return parseIfStatement(); - case 75 /* DoKeyword */: + case 75: return parseDoStatement(); - case 100 /* WhileKeyword */: + case 100: return parseWhileStatement(); - case 82 /* ForKeyword */: + case 82: return parseForOrForInOrForOfStatement(); - case 71 /* ContinueKeyword */: - return parseBreakOrContinueStatement(190 /* ContinueStatement */); - case 66 /* BreakKeyword */: - return parseBreakOrContinueStatement(191 /* BreakStatement */); - case 90 /* ReturnKeyword */: + case 71: + return parseBreakOrContinueStatement(190); + case 66: + return parseBreakOrContinueStatement(191); + case 90: return parseReturnStatement(); - case 101 /* WithKeyword */: + case 101: return parseWithStatement(); - case 92 /* SwitchKeyword */: + case 92: return parseSwitchStatement(); - case 94 /* ThrowKeyword */: + case 94: return parseThrowStatement(); - case 96 /* TryKeyword */: - // Include the next two for error recovery. - case 68 /* CatchKeyword */: - case 81 /* FinallyKeyword */: + case 96: + case 68: + case 81: return parseTryStatement(); - case 72 /* DebuggerKeyword */: + case 72: return parseDebuggerStatement(); - case 104 /* LetKeyword */: - // If let follows identifier on the same line, it is declaration parse it as variable statement + case 104: if (isLetDeclaration()) { return parseVariableStatement(scanner.getStartPos(), undefined, undefined); } - // Else parse it like identifier - fall through default: - // Functions and variable statements are allowed as a statement. But as per - // the grammar, they also allow modifiers. So we have to check for those - // statements that might be following modifiers. This ensures that things - // work properly when incrementally parsing as the parser will produce the - // same FunctionDeclaraiton or VariableStatement if it has the same text - // regardless of whether it is inside a block or not. - // Even though variable statements and function declarations cannot have decorators, - // we parse them here to provide better error recovery. - if (ts.isModifier(token) || token === 52 /* AtToken */) { + if (ts.isModifier(token) || token === 52) { var result = tryParse(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers); if (result) { return result; @@ -9127,54 +7298,52 @@ var ts; var decorators = parseDecorators(); var modifiers = parseModifiers(); switch (token) { - case 70 /* ConstKeyword */: + case 70: var nextTokenIsEnum = lookAhead(nextTokenIsEnumKeyword); if (nextTokenIsEnum) { return undefined; } return parseVariableStatement(start, decorators, modifiers); - case 104 /* LetKeyword */: + case 104: if (!isLetDeclaration()) { return undefined; } return parseVariableStatement(start, decorators, modifiers); - case 98 /* VarKeyword */: + case 98: return parseVariableStatement(start, decorators, modifiers); - case 83 /* FunctionKeyword */: + case 83: return parseFunctionDeclaration(start, decorators, modifiers); - case 69 /* ClassKeyword */: + case 69: return parseClassDeclaration(start, decorators, modifiers); } return undefined; } function parseFunctionBlockOrSemicolon(isGenerator, diagnosticMessage) { - if (token !== 14 /* OpenBraceToken */ && canParseSemicolon()) { + if (token !== 14 && canParseSemicolon()) { parseSemicolon(); return; } return parseFunctionBlock(isGenerator, false, diagnosticMessage); } - // DECLARATIONS function parseArrayBindingElement() { - if (token === 23 /* CommaToken */) { - return createNode(176 /* OmittedExpression */); + if (token === 23) { + return createNode(176); } - var node = createNode(153 /* BindingElement */); - node.dotDotDotToken = parseOptionalToken(21 /* DotDotDotToken */); + var node = createNode(153); + node.dotDotDotToken = parseOptionalToken(21); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(153 /* BindingElement */); - // TODO(andersh): Handle computed properties + var node = createNode(153); var tokenIsIdentifier = isIdentifier(); var propertyName = parsePropertyName(); - if (tokenIsIdentifier && token !== 51 /* ColonToken */) { + if (tokenIsIdentifier && token !== 51) { node.name = propertyName; } else { - parseExpected(51 /* ColonToken */); + parseExpected(51); node.propertyName = propertyName; node.name = parseIdentifierOrPattern(); } @@ -9182,33 +7351,33 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(151 /* ObjectBindingPattern */); - parseExpected(14 /* OpenBraceToken */); - node.elements = parseDelimitedList(10 /* ObjectBindingElements */, parseObjectBindingElement); - parseExpected(15 /* CloseBraceToken */); + var node = createNode(151); + parseExpected(14); + node.elements = parseDelimitedList(10, parseObjectBindingElement); + parseExpected(15); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(152 /* ArrayBindingPattern */); - parseExpected(18 /* OpenBracketToken */); - node.elements = parseDelimitedList(11 /* ArrayBindingElements */, parseArrayBindingElement); - parseExpected(19 /* CloseBracketToken */); + var node = createNode(152); + parseExpected(18); + node.elements = parseDelimitedList(11, parseArrayBindingElement); + parseExpected(19); return finishNode(node); } function isIdentifierOrPattern() { - return token === 14 /* OpenBraceToken */ || token === 18 /* OpenBracketToken */ || isIdentifier(); + return token === 14 || token === 18 || isIdentifier(); } function parseIdentifierOrPattern() { - if (token === 18 /* OpenBracketToken */) { + if (token === 18) { return parseArrayBindingPattern(); } - if (token === 14 /* OpenBraceToken */) { + if (token === 14) { return parseObjectBindingPattern(); } return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(199 /* VariableDeclaration */); + var node = createNode(199); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -9217,45 +7386,36 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(200 /* VariableDeclarationList */); + var node = createNode(200); switch (token) { - case 98 /* VarKeyword */: + case 98: break; - case 104 /* LetKeyword */: - node.flags |= 4096 /* Let */; + case 104: + node.flags |= 4096; break; - case 70 /* ConstKeyword */: - node.flags |= 8192 /* Const */; + case 70: + node.flags |= 8192; break; default: ts.Debug.fail(); } nextToken(); - // The user may have written the following: - // - // for (let of X) { } - // - // In this case, we want to parse an empty declaration list, and then parse 'of' - // as a keyword. The reason this is not automatic is that 'of' is a valid identifier. - // So we need to look ahead to determine if 'of' should be treated as a keyword in - // this context. - // The checker will then give an error that there is an empty declaration list. - if (token === 126 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) { + if (token === 126 && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { var savedDisallowIn = inDisallowInContext(); setDisallowInContext(inForStatementInitializer); - node.declarations = parseDelimitedList(9 /* VariableDeclarations */, parseVariableDeclaration); + node.declarations = parseDelimitedList(9, parseVariableDeclaration); setDisallowInContext(savedDisallowIn); } return finishNode(node); } function canFollowContextualOfKeyword() { - return nextTokenIsIdentifier() && nextToken() === 17 /* CloseParenToken */; + return nextTokenIsIdentifier() && nextToken() === 17; } function parseVariableStatement(fullStart, decorators, modifiers) { - var node = createNode(181 /* VariableStatement */, fullStart); + var node = createNode(181, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); @@ -9263,38 +7423,38 @@ var ts; return finishNode(node); } function parseFunctionDeclaration(fullStart, decorators, modifiers) { - var node = createNode(201 /* FunctionDeclaration */, fullStart); + var node = createNode(201, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(83 /* FunctionKeyword */); - node.asteriskToken = parseOptionalToken(35 /* AsteriskToken */); - node.name = node.flags & 256 /* Default */ ? parseOptionalIdentifier() : parseIdentifier(); - fillSignature(51 /* ColonToken */, !!node.asteriskToken, false, node); + parseExpected(83); + node.asteriskToken = parseOptionalToken(35); + node.name = node.flags & 256 ? parseOptionalIdentifier() : parseIdentifier(); + fillSignature(51, !!node.asteriskToken, false, node); node.body = parseFunctionBlockOrSemicolon(!!node.asteriskToken, ts.Diagnostics.or_expected); return finishNode(node); } function parseConstructorDeclaration(pos, decorators, modifiers) { - var node = createNode(136 /* Constructor */, pos); + var node = createNode(136, pos); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(114 /* ConstructorKeyword */); - fillSignature(51 /* ColonToken */, false, false, node); + parseExpected(114); + fillSignature(51, false, false, node); node.body = parseFunctionBlockOrSemicolon(false, ts.Diagnostics.or_expected); return finishNode(node); } function parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(135 /* MethodDeclaration */, fullStart); + var method = createNode(135, fullStart); method.decorators = decorators; setModifiers(method, modifiers); method.asteriskToken = asteriskToken; method.name = name; method.questionToken = questionToken; - fillSignature(51 /* ColonToken */, !!asteriskToken, false, method); + fillSignature(51, !!asteriskToken, false, method); method.body = parseFunctionBlockOrSemicolon(!!asteriskToken, diagnosticMessage); return finishNode(method); } function parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken) { - var property = createNode(133 /* PropertyDeclaration */, fullStart); + var property = createNode(133, fullStart); property.decorators = decorators; setModifiers(property, modifiers); property.name = name; @@ -9305,12 +7465,10 @@ var ts; return finishNode(property); } function parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers) { - var asteriskToken = parseOptionalToken(35 /* AsteriskToken */); + var asteriskToken = parseOptionalToken(35); var name = parsePropertyName(); - // Note: this is not legal as per the grammar. But we allow it in the parser and - // report an error in the grammar checker. - var questionToken = parseOptionalToken(50 /* QuestionToken */); - if (asteriskToken || token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */) { + var questionToken = parseOptionalToken(50); + if (asteriskToken || token === 16 || token === 24) { return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected); } else { @@ -9325,16 +7483,16 @@ var ts; node.decorators = decorators; setModifiers(node, modifiers); node.name = parsePropertyName(); - fillSignature(51 /* ColonToken */, false, false, node); + fillSignature(51, false, false, node); node.body = parseFunctionBlockOrSemicolon(false); return finishNode(node); } function isClassMemberModifier(idToken) { switch (idToken) { - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: - case 109 /* StaticKeyword */: + case 108: + case 106: + case 107: + case 109: return true; default: return false; @@ -9342,57 +7500,38 @@ var ts; } function isClassMemberStart() { var idToken; - if (token === 52 /* AtToken */) { + if (token === 52) { return true; } - // Eat up all modifiers, but hold on to the last one in case it is actually an identifier. while (ts.isModifier(token)) { idToken = token; - // If the idToken is a class modifier (protected, private, public, and static), it is - // certain that we are starting to parse class member. This allows better error recovery - // Example: - // public foo() ... // true - // public @dec blah ... // true; we will then report an error later - // export public ... // true; we will then report an error later if (isClassMemberModifier(idToken)) { return true; } nextToken(); } - if (token === 35 /* AsteriskToken */) { + if (token === 35) { return true; } - // Try to get the first property-like token following all modifiers. - // This can either be an identifier or the 'get' or 'set' keywords. if (isLiteralPropertyName()) { idToken = token; nextToken(); } - // Index signatures and computed properties are class members; we can parse. - if (token === 18 /* OpenBracketToken */) { + if (token === 18) { return true; } - // If we were able to get any potential identifier... if (idToken !== undefined) { - // If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse. - if (!ts.isKeyword(idToken) || idToken === 121 /* SetKeyword */ || idToken === 116 /* GetKeyword */) { + if (!ts.isKeyword(idToken) || idToken === 121 || idToken === 116) { return true; } - // If it *is* a keyword, but not an accessor, check a little farther along - // to see if it should actually be parsed as a class member. switch (token) { - case 16 /* OpenParenToken */: // Method declaration - case 24 /* LessThanToken */: // Generic Method declaration - case 51 /* ColonToken */: // Type Annotation for declaration - case 53 /* EqualsToken */: // Initializer for declaration - case 50 /* QuestionToken */: + case 16: + case 24: + case 51: + case 53: + case 50: return true; default: - // Covers - // - Semicolons (declaration termination) - // - Closing braces (end-of-class, must be declaration) - // - End-of-files (not valid, but permitted so that it gets caught later on) - // - Line-breaks (enabling *automatic semicolon insertion*) return canParseSemicolon(); } } @@ -9402,14 +7541,14 @@ var ts; var decorators; while (true) { var decoratorStart = getNodePos(); - if (!parseOptional(52 /* AtToken */)) { + if (!parseOptional(52)) { break; } if (!decorators) { decorators = []; decorators.pos = scanner.getStartPos(); } - var decorator = createNode(131 /* Decorator */, decoratorStart); + var decorator = createNode(131, decoratorStart); decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher); decorators.push(finishNode(decorator)); } @@ -9441,8 +7580,8 @@ var ts; return modifiers; } function parseClassElement() { - if (token === 22 /* SemicolonToken */) { - var result = createNode(179 /* SemicolonClassElement */); + if (token === 22) { + var result = createNode(179); nextToken(); return finishNode(result); } @@ -9453,57 +7592,46 @@ var ts; if (accessor) { return accessor; } - if (token === 114 /* ConstructorKeyword */) { + if (token === 114) { return parseConstructorDeclaration(fullStart, decorators, modifiers); } if (isIndexSignature()) { return parseIndexSignatureDeclaration(fullStart, decorators, modifiers); } - // It is very important that we check this *after* checking indexers because - // the [ token can start an index signature or a computed property name if (isIdentifierOrKeyword() || - token === 8 /* StringLiteral */ || - token === 7 /* NumericLiteral */ || - token === 35 /* AsteriskToken */ || - token === 18 /* OpenBracketToken */) { + token === 8 || + token === 7 || + token === 35 || + token === 18) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } if (decorators) { - // treat this as a property declaration with a missing name. - var name_3 = createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Declaration_expected); + var name_3 = createMissingNode(65, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_3, undefined); } - // 'isClassMemberStart' should have hinted not to attempt parsing. ts.Debug.fail("Should not have attempted to parse class member declaration."); } function parseClassExpression() { - return parseClassDeclarationOrExpression( - /*fullStart:*/ scanner.getStartPos(), - /*decorators:*/ undefined, - /*modifiers:*/ undefined, 175 /* ClassExpression */); + return parseClassDeclarationOrExpression(scanner.getStartPos(), undefined, undefined, 175); } function parseClassDeclaration(fullStart, decorators, modifiers) { - return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 202 /* ClassDeclaration */); + return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 202); } function parseClassDeclarationOrExpression(fullStart, decorators, modifiers, kind) { - // In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code var savedStrictModeContext = inStrictModeContext(); setStrictModeContext(true); var node = createNode(kind, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(69 /* ClassKeyword */); + parseExpected(69); node.name = parseOptionalIdentifier(); node.typeParameters = parseTypeParameters(); node.heritageClauses = parseHeritageClauses(true); - if (parseExpected(14 /* OpenBraceToken */)) { - // ClassTail[Yield,GeneratorParameter] : See 14.5 - // [~GeneratorParameter]ClassHeritage[?Yield]opt { ClassBody[?Yield]opt } - // [+GeneratorParameter] ClassHeritageopt { ClassBodyopt } + if (parseExpected(14)) { node.members = inGeneratorParameterContext() ? doOutsideOfYieldContext(parseClassMembers) : parseClassMembers(); - parseExpected(15 /* CloseBraceToken */); + parseExpected(15); } else { node.members = createMissingList(); @@ -9524,37 +7652,37 @@ var ts; return undefined; } function parseHeritageClausesWorker() { - return parseList(19 /* HeritageClauses */, false, parseHeritageClause); + return parseList(19, false, parseHeritageClause); } function parseHeritageClause() { - if (token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */) { - var node = createNode(223 /* HeritageClause */); + if (token === 79 || token === 102) { + var node = createNode(223); node.token = token; nextToken(); - node.types = parseDelimitedList(8 /* HeritageClauseElement */, parseExpressionWithTypeArguments); + node.types = parseDelimitedList(8, parseExpressionWithTypeArguments); return finishNode(node); } return undefined; } function parseExpressionWithTypeArguments() { - var node = createNode(177 /* ExpressionWithTypeArguments */); + var node = createNode(177); node.expression = parseLeftHandSideExpressionOrHigher(); - if (token === 24 /* LessThanToken */) { - node.typeArguments = parseBracketedList(17 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + if (token === 24) { + node.typeArguments = parseBracketedList(17, parseType, 24, 25); } return finishNode(node); } function isHeritageClause() { - return token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; + return token === 79 || token === 102; } function parseClassMembers() { - return parseList(6 /* ClassMembers */, false, parseClassElement); + return parseList(6, false, parseClassElement); } function parseInterfaceDeclaration(fullStart, decorators, modifiers) { - var node = createNode(203 /* InterfaceDeclaration */, fullStart); + var node = createNode(203, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(103 /* InterfaceKeyword */); + parseExpected(103); node.name = parseIdentifier(); node.typeParameters = parseTypeParameters(); node.heritageClauses = parseHeritageClauses(false); @@ -9562,35 +7690,31 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, decorators, modifiers) { - var node = createNode(204 /* TypeAliasDeclaration */, fullStart); + var node = createNode(204, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(124 /* TypeKeyword */); + parseExpected(124); node.name = parseIdentifier(); - parseExpected(53 /* EqualsToken */); + parseExpected(53); node.type = parseType(); parseSemicolon(); return finishNode(node); } - // In an ambient declaration, the grammar only allows integer literals as initializers. - // In a non-ambient declaration, the grammar allows uninitialized members only in a - // ConstantEnumMemberSection, which starts at the beginning of an enum declaration - // or any time an integer literal initializer is encountered. function parseEnumMember() { - var node = createNode(227 /* EnumMember */, scanner.getStartPos()); + var node = createNode(227, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, decorators, modifiers) { - var node = createNode(205 /* EnumDeclaration */, fullStart); + var node = createNode(205, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(77 /* EnumKeyword */); + parseExpected(77); node.name = parseIdentifier(); - if (parseExpected(14 /* OpenBraceToken */)) { - node.members = parseDelimitedList(7 /* EnumMembers */, parseEnumMember); - parseExpected(15 /* CloseBraceToken */); + if (parseExpected(14)) { + node.members = parseDelimitedList(7, parseEnumMember); + parseExpected(15); } else { node.members = createMissingList(); @@ -9598,10 +7722,10 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(207 /* ModuleBlock */, scanner.getStartPos()); - if (parseExpected(14 /* OpenBraceToken */)) { - node.statements = parseList(1 /* ModuleElements */, false, parseModuleElement); - parseExpected(15 /* CloseBraceToken */); + var node = createNode(207, scanner.getStartPos()); + if (parseExpected(14)) { + node.statements = parseList(1, false, parseModuleElement); + parseExpected(15); } else { node.statements = createMissingList(); @@ -9609,18 +7733,18 @@ var ts; return finishNode(node); } function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) { - var node = createNode(206 /* ModuleDeclaration */, fullStart); + var node = createNode(206, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.flags |= flags; node.name = parseIdentifier(); - node.body = parseOptional(20 /* DotToken */) - ? parseModuleOrNamespaceDeclaration(getNodePos(), undefined, undefined, 1 /* Export */) + node.body = parseOptional(20) + ? parseModuleOrNamespaceDeclaration(getNodePos(), undefined, undefined, 1) : parseModuleBlock(); return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers) { - var node = createNode(206 /* ModuleDeclaration */, fullStart); + var node = createNode(206, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.name = parseLiteralNode(true); @@ -9629,61 +7753,54 @@ var ts; } function parseModuleDeclaration(fullStart, decorators, modifiers) { var flags = modifiers ? modifiers.flags : 0; - if (parseOptional(118 /* NamespaceKeyword */)) { - flags |= 32768 /* Namespace */; + if (parseOptional(118)) { + flags |= 32768; } else { - parseExpected(117 /* ModuleKeyword */); - if (token === 8 /* StringLiteral */) { + parseExpected(117); + if (token === 8) { return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers); } } return parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags); } function isExternalModuleReference() { - return token === 119 /* RequireKeyword */ && + return token === 119 && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { - return nextToken() === 16 /* OpenParenToken */; + return nextToken() === 16; } function nextTokenIsCommaOrFromKeyword() { nextToken(); - return token === 23 /* CommaToken */ || - token === 125 /* FromKeyword */; + return token === 23 || + token === 125; } function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) { - parseExpected(85 /* ImportKeyword */); + parseExpected(85); var afterImportPos = scanner.getStartPos(); var identifier; if (isIdentifier()) { identifier = parseIdentifier(); - if (token !== 23 /* CommaToken */ && token !== 125 /* FromKeyword */) { - // ImportEquals declaration of type: - // import x = require("mod"); or - // import x = M.x; - var importEqualsDeclaration = createNode(209 /* ImportEqualsDeclaration */, fullStart); + if (token !== 23 && token !== 125) { + var importEqualsDeclaration = createNode(209, fullStart); importEqualsDeclaration.decorators = decorators; setModifiers(importEqualsDeclaration, modifiers); importEqualsDeclaration.name = identifier; - parseExpected(53 /* EqualsToken */); + parseExpected(53); importEqualsDeclaration.moduleReference = parseModuleReference(); parseSemicolon(); return finishNode(importEqualsDeclaration); } } - // Import statement - var importDeclaration = createNode(210 /* ImportDeclaration */, fullStart); + var importDeclaration = createNode(210, fullStart); importDeclaration.decorators = decorators; setModifiers(importDeclaration, modifiers); - // ImportDeclaration: - // import ImportClause from ModuleSpecifier ; - // import ModuleSpecifier; if (identifier || - token === 35 /* AsteriskToken */ || - token === 14 /* OpenBraceToken */) { + token === 35 || + token === 14) { importDeclaration.importClause = parseImportClause(identifier, afterImportPos); - parseExpected(125 /* FromKeyword */); + parseExpected(125); } importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); @@ -9696,17 +7813,13 @@ var ts; // NamedImports // ImportedDefaultBinding, NameSpaceImport // ImportedDefaultBinding, NamedImports - var importClause = createNode(211 /* ImportClause */, fullStart); + var importClause = createNode(211, fullStart); if (identifier) { - // ImportedDefaultBinding: - // ImportedBinding importClause.name = identifier; } - // If there was no default import or if there is comma token after default import - // parse namespace or named imports if (!importClause.name || - parseOptional(23 /* CommaToken */)) { - importClause.namedBindings = token === 35 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(213 /* NamedImports */); + parseOptional(23)) { + importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(213); } return finishNode(importClause); } @@ -9716,67 +7829,47 @@ var ts; : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(220 /* ExternalModuleReference */); - parseExpected(119 /* RequireKeyword */); - parseExpected(16 /* OpenParenToken */); + var node = createNode(220); + parseExpected(119); + parseExpected(16); node.expression = parseModuleSpecifier(); - parseExpected(17 /* CloseParenToken */); + parseExpected(17); return finishNode(node); } function parseModuleSpecifier() { - // We allow arbitrary expressions here, even though the grammar only allows string - // literals. We check to ensure that it is only a string literal later in the grammar - // walker. var result = parseExpression(); - // Ensure the string being required is in our 'identifier' table. This will ensure - // that features like 'find refs' will look inside this file when search for its name. - if (result.kind === 8 /* StringLiteral */) { + if (result.kind === 8) { internIdentifier(result.text); } return result; } function parseNamespaceImport() { - // NameSpaceImport: - // * as ImportedBinding - var namespaceImport = createNode(212 /* NamespaceImport */); - parseExpected(35 /* AsteriskToken */); - parseExpected(111 /* AsKeyword */); + var namespaceImport = createNode(212); + parseExpected(35); + parseExpected(111); namespaceImport.name = parseIdentifier(); return finishNode(namespaceImport); } function parseNamedImportsOrExports(kind) { var node = createNode(kind); - // NamedImports: - // { } - // { ImportsList } - // { ImportsList, } - // ImportsList: - // ImportSpecifier - // ImportsList, ImportSpecifier - node.elements = parseBracketedList(20 /* ImportOrExportSpecifiers */, kind === 213 /* NamedImports */ ? parseImportSpecifier : parseExportSpecifier, 14 /* OpenBraceToken */, 15 /* CloseBraceToken */); + node.elements = parseBracketedList(20, kind === 213 ? parseImportSpecifier : parseExportSpecifier, 14, 15); return finishNode(node); } function parseExportSpecifier() { - return parseImportOrExportSpecifier(218 /* ExportSpecifier */); + return parseImportOrExportSpecifier(218); } function parseImportSpecifier() { - return parseImportOrExportSpecifier(214 /* ImportSpecifier */); + return parseImportOrExportSpecifier(214); } function parseImportOrExportSpecifier(kind) { var node = createNode(kind); - // ImportSpecifier: - // BindingIdentifier - // IdentifierName as BindingIdentifier - // ExportSpecififer: - // IdentifierName - // IdentifierName as IdentifierName var checkIdentifierIsKeyword = ts.isKeyword(token) && !isIdentifier(); var checkIdentifierStart = scanner.getTokenPos(); var checkIdentifierEnd = scanner.getTextPos(); var identifierName = parseIdentifierName(); - if (token === 111 /* AsKeyword */) { + if (token === 111) { node.propertyName = identifierName; - parseExpected(111 /* AsKeyword */); + parseExpected(111); checkIdentifierIsKeyword = ts.isKeyword(token) && !isIdentifier(); checkIdentifierStart = scanner.getTokenPos(); checkIdentifierEnd = scanner.getTextPos(); @@ -9785,23 +7878,22 @@ var ts; else { node.name = identifierName; } - if (kind === 214 /* ImportSpecifier */ && checkIdentifierIsKeyword) { - // Report error identifier expected + if (kind === 214 && checkIdentifierIsKeyword) { parseErrorAtPosition(checkIdentifierStart, checkIdentifierEnd - checkIdentifierStart, ts.Diagnostics.Identifier_expected); } return finishNode(node); } function parseExportDeclaration(fullStart, decorators, modifiers) { - var node = createNode(216 /* ExportDeclaration */, fullStart); + var node = createNode(216, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - if (parseOptional(35 /* AsteriskToken */)) { - parseExpected(125 /* FromKeyword */); + if (parseOptional(35)) { + parseExpected(125); node.moduleSpecifier = parseModuleSpecifier(); } else { - node.exportClause = parseNamedImportsOrExports(217 /* NamedExports */); - if (parseOptional(125 /* FromKeyword */)) { + node.exportClause = parseNamedImportsOrExports(217); + if (parseOptional(125)) { node.moduleSpecifier = parseModuleSpecifier(); } } @@ -9809,63 +7901,54 @@ var ts; return finishNode(node); } function parseExportAssignment(fullStart, decorators, modifiers) { - var node = createNode(215 /* ExportAssignment */, fullStart); + var node = createNode(215, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - if (parseOptional(53 /* EqualsToken */)) { + if (parseOptional(53)) { node.isExportEquals = true; } else { - parseExpected(73 /* DefaultKeyword */); + parseExpected(73); } node.expression = parseAssignmentExpressionOrHigher(); parseSemicolon(); return finishNode(node); } function isLetDeclaration() { - // It is let declaration if in strict mode or next token is identifier\open bracket\open curly on same line. - // otherwise it needs to be treated like identifier return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine); } function isDeclarationStart(followsModifier) { switch (token) { - case 98 /* VarKeyword */: - case 70 /* ConstKeyword */: - case 83 /* FunctionKeyword */: + case 98: + case 70: + case 83: return true; - case 104 /* LetKeyword */: + case 104: return isLetDeclaration(); - case 69 /* ClassKeyword */: - case 103 /* InterfaceKeyword */: - case 77 /* EnumKeyword */: - case 124 /* TypeKeyword */: - // Not true keywords so ensure an identifier follows + case 69: + case 103: + case 77: + case 124: return lookAhead(nextTokenIsIdentifierOrKeyword); - case 85 /* ImportKeyword */: - // Not true keywords so ensure an identifier follows or is string literal or asterisk or open brace + case 85: return lookAhead(nextTokenCanFollowImportKeyword); - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: - // Not a true keyword so ensure an identifier or string literal follows + case 117: + case 118: return lookAhead(nextTokenIsIdentifierOrKeywordOrStringLiteral); - case 78 /* ExportKeyword */: - // Check for export assignment or modifier on source element + case 78: return lookAhead(nextTokenCanFollowExportKeyword); - case 115 /* DeclareKeyword */: - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: - case 109 /* StaticKeyword */: - // Check for modifier on source element + case 115: + case 108: + case 106: + case 107: + case 109: return lookAhead(nextTokenIsDeclarationStart); - case 52 /* AtToken */: - // a lookahead here is too costly, and decorators are only valid on a declaration. - // We will assume we are parsing a declaration here and report an error later + case 52: return !followsModifier; } } function isIdentifierOrKeyword() { - return token >= 65 /* Identifier */; + return token >= 65; } function nextTokenIsIdentifierOrKeyword() { nextToken(); @@ -9873,63 +7956,61 @@ var ts; } function nextTokenIsIdentifierOrKeywordOrStringLiteral() { nextToken(); - return isIdentifierOrKeyword() || token === 8 /* StringLiteral */; + return isIdentifierOrKeyword() || token === 8; } function nextTokenCanFollowImportKeyword() { nextToken(); - return isIdentifierOrKeyword() || token === 8 /* StringLiteral */ || - token === 35 /* AsteriskToken */ || token === 14 /* OpenBraceToken */; + return isIdentifierOrKeyword() || token === 8 || + token === 35 || token === 14; } function nextTokenCanFollowExportKeyword() { nextToken(); - return token === 53 /* EqualsToken */ || token === 35 /* AsteriskToken */ || - token === 14 /* OpenBraceToken */ || token === 73 /* DefaultKeyword */ || isDeclarationStart(true); + return token === 53 || token === 35 || + token === 14 || token === 73 || isDeclarationStart(true); } function nextTokenIsDeclarationStart() { nextToken(); return isDeclarationStart(true); } function nextTokenIsAsKeyword() { - return nextToken() === 111 /* AsKeyword */; + return nextToken() === 111; } function parseDeclaration() { var fullStart = getNodePos(); var decorators = parseDecorators(); var modifiers = parseModifiers(); - if (token === 78 /* ExportKeyword */) { + if (token === 78) { nextToken(); - if (token === 73 /* DefaultKeyword */ || token === 53 /* EqualsToken */) { + if (token === 73 || token === 53) { return parseExportAssignment(fullStart, decorators, modifiers); } - if (token === 35 /* AsteriskToken */ || token === 14 /* OpenBraceToken */) { + if (token === 35 || token === 14) { return parseExportDeclaration(fullStart, decorators, modifiers); } } switch (token) { - case 98 /* VarKeyword */: - case 104 /* LetKeyword */: - case 70 /* ConstKeyword */: + case 98: + case 104: + case 70: return parseVariableStatement(fullStart, decorators, modifiers); - case 83 /* FunctionKeyword */: + case 83: return parseFunctionDeclaration(fullStart, decorators, modifiers); - case 69 /* ClassKeyword */: + case 69: return parseClassDeclaration(fullStart, decorators, modifiers); - case 103 /* InterfaceKeyword */: + case 103: return parseInterfaceDeclaration(fullStart, decorators, modifiers); - case 124 /* TypeKeyword */: + case 124: return parseTypeAliasDeclaration(fullStart, decorators, modifiers); - case 77 /* EnumKeyword */: + case 77: return parseEnumDeclaration(fullStart, decorators, modifiers); - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: + case 117: + case 118: return parseModuleDeclaration(fullStart, decorators, modifiers); - case 85 /* ImportKeyword */: + case 85: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); default: if (decorators) { - // We reached this point because we encountered an AtToken and assumed a declaration would - // follow. For recovery and error reporting purposes, return an incomplete declaration. - var node = createMissingNode(219 /* MissingDeclaration */, true, ts.Diagnostics.Declaration_expected); + var node = createMissingNode(219, true, ts.Diagnostics.Declaration_expected); node.pos = fullStart; node.decorators = decorators; setModifiers(node, modifiers); @@ -9957,15 +8038,12 @@ var ts; var referencedFiles = []; var amdDependencies = []; var amdModuleName; - // Keep scanning all the leading trivia in the file until we get to something that - // isn't trivia. Any single line comment will be analyzed to see if it is a - // reference comment. while (true) { var kind = triviaScanner.scan(); - if (kind === 5 /* WhitespaceTrivia */ || kind === 4 /* NewLineTrivia */ || kind === 3 /* MultiLineCommentTrivia */) { + if (kind === 5 || kind === 4 || kind === 3) { continue; } - if (kind !== 2 /* SingleLineCommentTrivia */) { + if (kind !== 2) { break; } var range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() }; @@ -10011,115 +8089,39 @@ var ts; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { - return node.flags & 1 /* Export */ - || node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 220 /* ExternalModuleReference */ - || node.kind === 210 /* ImportDeclaration */ - || node.kind === 215 /* ExportAssignment */ - || node.kind === 216 /* ExportDeclaration */ + return node.flags & 1 + || node.kind === 209 && node.moduleReference.kind === 220 + || node.kind === 210 + || node.kind === 215 + || node.kind === 216 ? node : undefined; }); } - var ParsingContext; - (function (ParsingContext) { - ParsingContext[ParsingContext["SourceElements"] = 0] = "SourceElements"; - ParsingContext[ParsingContext["ModuleElements"] = 1] = "ModuleElements"; - ParsingContext[ParsingContext["BlockStatements"] = 2] = "BlockStatements"; - ParsingContext[ParsingContext["SwitchClauses"] = 3] = "SwitchClauses"; - ParsingContext[ParsingContext["SwitchClauseStatements"] = 4] = "SwitchClauseStatements"; - ParsingContext[ParsingContext["TypeMembers"] = 5] = "TypeMembers"; - ParsingContext[ParsingContext["ClassMembers"] = 6] = "ClassMembers"; - ParsingContext[ParsingContext["EnumMembers"] = 7] = "EnumMembers"; - ParsingContext[ParsingContext["HeritageClauseElement"] = 8] = "HeritageClauseElement"; - ParsingContext[ParsingContext["VariableDeclarations"] = 9] = "VariableDeclarations"; - ParsingContext[ParsingContext["ObjectBindingElements"] = 10] = "ObjectBindingElements"; - ParsingContext[ParsingContext["ArrayBindingElements"] = 11] = "ArrayBindingElements"; - ParsingContext[ParsingContext["ArgumentExpressions"] = 12] = "ArgumentExpressions"; - ParsingContext[ParsingContext["ObjectLiteralMembers"] = 13] = "ObjectLiteralMembers"; - ParsingContext[ParsingContext["ArrayLiteralMembers"] = 14] = "ArrayLiteralMembers"; - ParsingContext[ParsingContext["Parameters"] = 15] = "Parameters"; - ParsingContext[ParsingContext["TypeParameters"] = 16] = "TypeParameters"; - ParsingContext[ParsingContext["TypeArguments"] = 17] = "TypeArguments"; - ParsingContext[ParsingContext["TupleElementTypes"] = 18] = "TupleElementTypes"; - ParsingContext[ParsingContext["HeritageClauses"] = 19] = "HeritageClauses"; - ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 20] = "ImportOrExportSpecifiers"; - ParsingContext[ParsingContext["Count"] = 21] = "Count"; // Number of parsing contexts - })(ParsingContext || (ParsingContext = {})); - var Tristate; - (function (Tristate) { - Tristate[Tristate["False"] = 0] = "False"; - Tristate[Tristate["True"] = 1] = "True"; - Tristate[Tristate["Unknown"] = 2] = "Unknown"; - })(Tristate || (Tristate = {})); })(Parser || (Parser = {})); var IncrementalParser; (function (IncrementalParser) { function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) { - aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2 /* Aggressive */); + aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2); checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks); if (ts.textChangeRangeIsUnchanged(textChangeRange)) { - // if the text didn't change, then we can just return our current source file as-is. return sourceFile; } if (sourceFile.statements.length === 0) { - // If we don't have any statements in the current source file, then there's no real - // way to incrementally parse. So just do a full parse instead. return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, undefined, true); } - // Make sure we're not trying to incrementally update a source file more than once. Once - // we do an update the original source file is considered unusbale from that point onwards. - // - // This is because we do incremental parsing in-place. i.e. we take nodes from the old - // tree and give them new positions and parents. From that point on, trusting the old - // tree at all is not possible as far too much of it may violate invariants. var incrementalSourceFile = sourceFile; ts.Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed); incrementalSourceFile.hasBeenIncrementallyParsed = true; var oldText = sourceFile.text; var syntaxCursor = createSyntaxCursor(sourceFile); - // Make the actual change larger so that we know to reparse anything whose lookahead - // might have intersected the change. var changeRange = extendToAffectedRange(sourceFile, textChangeRange); checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks); - // Ensure that extending the affected range only moved the start of the change range - // earlier in the file. ts.Debug.assert(changeRange.span.start <= textChangeRange.span.start); ts.Debug.assert(ts.textSpanEnd(changeRange.span) === ts.textSpanEnd(textChangeRange.span)); ts.Debug.assert(ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)) === ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange))); - // The is the amount the nodes after the edit range need to be adjusted. It can be - // positive (if the edit added characters), negative (if the edit deleted characters) - // or zero (if this was a pure overwrite with nothing added/removed). var delta = ts.textChangeRangeNewSpan(changeRange).length - changeRange.span.length; - // If we added or removed characters during the edit, then we need to go and adjust all - // the nodes after the edit. Those nodes may move forward (if we inserted chars) or they - // may move backward (if we deleted chars). - // - // Doing this helps us out in two ways. First, it means that any nodes/tokens we want - // to reuse are already at the appropriate position in the new text. That way when we - // reuse them, we don't have to figure out if they need to be adjusted. Second, it makes - // it very easy to determine if we can reuse a node. If the node's position is at where - // we are in the text, then we can reuse it. Otherwise we can't. If the node's position - // is ahead of us, then we'll need to rescan tokens. If the node's position is behind - // us, then we'll need to skip it or crumble it as appropriate - // - // We will also adjust the positions of nodes that intersect the change range as well. - // By doing this, we ensure that all the positions in the old tree are consistent, not - // just the positions of nodes entirely before/after the change range. By being - // consistent, we can then easily map from positions to nodes in the old tree easily. - // - // Also, mark any syntax elements that intersect the changed span. We know, up front, - // that we cannot reuse these elements. updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks); - // Now that we've set up our internal incremental state just proceed and parse the - // source file in the normal fashion. When possible the parser will retrieve and - // reuse nodes from the old tree. - // - // Note: passing in 'true' for setNodeParents is very important. When incrementally - // parsing, we will be reusing nodes from the old tree, and placing it into new - // parents. If we don't set the parents now, we'll end up with an observably - // inconsistent tree. Setting the parents on the new tree should be very fast. We - // will immediately bail out of walking any subtrees when we can see that their parents - // are already correct. var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true); return result; } @@ -10136,8 +8138,6 @@ var ts; if (aggressiveChecks && shouldCheckNode(node)) { var text = oldText.substring(node.pos, node.end); } - // Ditch any existing LS children we may have created. This way we can avoid - // moving them forward. node._children = undefined; node.pos += delta; node.end += delta; @@ -10159,9 +8159,9 @@ var ts; } function shouldCheckNode(node) { switch (node.kind) { - case 8 /* StringLiteral */: - case 7 /* NumericLiteral */: - case 65 /* Identifier */: + case 8: + case 7: + case 65: return true; } return false; @@ -10170,63 +8170,11 @@ var ts; ts.Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range"); ts.Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range"); ts.Debug.assert(element.pos <= element.end); - // We have an element that intersects the change range in some way. It may have its - // start, or its end (or both) in the changed range. We want to adjust any part - // that intersects such that the final tree is in a consistent state. i.e. all - // chlidren have spans within the span of their parent, and all siblings are ordered - // properly. - // We may need to update both the 'pos' and the 'end' of the element. - // If the 'pos' is before the start of the change, then we don't need to touch it. - // If it isn't, then the 'pos' must be inside the change. How we update it will - // depend if delta is positive or negative. If delta is positive then we have - // something like: - // - // -------------------AAA----------------- - // -------------------BBBCCCCCCC----------------- - // - // In this case, we consider any node that started in the change range to still be - // starting at the same position. - // - // however, if the delta is negative, then we instead have something like this: - // - // -------------------XXXYYYYYYY----------------- - // -------------------ZZZ----------------- - // - // In this case, any element that started in the 'X' range will keep its position. - // However any element htat started after that will have their pos adjusted to be - // at the end of the new range. i.e. any node that started in the 'Y' range will - // be adjusted to have their start at the end of the 'Z' range. - // - // The element will keep its position if possible. Or Move backward to the new-end - // if it's in the 'Y' range. element.pos = Math.min(element.pos, changeRangeNewEnd); - // If the 'end' is after the change range, then we always adjust it by the delta - // amount. However, if the end is in the change range, then how we adjust it - // will depend on if delta is positive or negative. If delta is positive then we - // have something like: - // - // -------------------AAA----------------- - // -------------------BBBCCCCCCC----------------- - // - // In this case, we consider any node that ended inside the change range to keep its - // end position. - // - // however, if the delta is negative, then we instead have something like this: - // - // -------------------XXXYYYYYYY----------------- - // -------------------ZZZ----------------- - // - // In this case, any element that ended in the 'X' range will keep its position. - // However any element htat ended after that will have their pos adjusted to be - // at the end of the new range. i.e. any node that ended in the 'Y' range will - // be adjusted to have their end at the end of the 'Z' range. if (element.end >= changeRangeOldEnd) { - // Element ends after the change range. Always adjust the end pos. element.end += delta; } else { - // Element ends in the change range. The element will keep its position if - // possible. Or Move backward to the new-end if it's in the 'Y' range. element.end = Math.min(element.end, changeRangeNewEnd); } ts.Debug.assert(element.pos <= element.end); @@ -10251,43 +8199,30 @@ var ts; function visitNode(child) { ts.Debug.assert(child.pos <= child.end); if (child.pos > changeRangeOldEnd) { - // Node is entirely past the change range. We need to move both its pos and - // end, forward or backward appropriately. moveElementEntirelyPastChangeRange(child, false, delta, oldText, newText, aggressiveChecks); return; } - // Check if the element intersects the change range. If it does, then it is not - // reusable. Also, we'll need to recurse to see what constituent portions we may - // be able to use. var fullEnd = child.end; if (fullEnd >= changeStart) { child.intersectsChange = true; child._children = undefined; - // Adjust the pos or end (or both) of the intersecting element accordingly. adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); forEachChild(child, visitNode, visitArray); checkNodePositions(child, aggressiveChecks); return; } - // Otherwise, the node is entirely before the change range. No need to do anything with it. ts.Debug.assert(fullEnd < changeStart); } function visitArray(array) { ts.Debug.assert(array.pos <= array.end); if (array.pos > changeRangeOldEnd) { - // Array is entirely after the change range. We need to move it, and move any of - // its children. moveElementEntirelyPastChangeRange(array, true, delta, oldText, newText, aggressiveChecks); return; } - // Check if the element intersects the change range. If it does, then it is not - // reusable. Also, we'll need to recurse to see what constituent portions we may - // be able to use. var fullEnd = array.end; if (fullEnd >= changeStart) { array.intersectsChange = true; array._children = undefined; - // Adjust the pos or end (or both) of the intersecting array accordingly. adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); for (var _i = 0; _i < array.length; _i++) { var node = array[_i]; @@ -10295,26 +8230,12 @@ var ts; } return; } - // Otherwise, the array is entirely before the change range. No need to do anything with it. ts.Debug.assert(fullEnd < changeStart); } } function extendToAffectedRange(sourceFile, changeRange) { - // Consider the following code: - // void foo() { /; } - // - // If the text changes with an insertion of / just before the semicolon then we end up with: - // void foo() { //; } - // - // If we were to just use the changeRange a is, then we would not rescan the { token - // (as it does not intersect the actual original change range). Because an edit may - // change the token touching it, we actually need to look back *at least* one token so - // that the prior token sees that change. var maxLookahead = 1; var start = changeRange.span.start; - // the first iteration aligns us with the change start. subsequent iteration move us to - // the left by maxLookahead tokens. We only need to do this as long as we're not at the - // start of the tree. for (var i = 0; start > 0 && i <= maxLookahead; i++) { var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start); ts.Debug.assert(nearestNode.pos <= start); @@ -10358,54 +8279,23 @@ var ts; } function visit(child) { if (ts.nodeIsMissing(child)) { - // Missing nodes are effectively invisible to us. We never even consider them - // When trying to find the nearest node before us. return; } - // If the child intersects this position, then this node is currently the nearest - // node that starts before the position. if (child.pos <= position) { if (child.pos >= bestResult.pos) { - // This node starts before the position, and is closer to the position than - // the previous best node we found. It is now the new best node. bestResult = child; } - // Now, the node may overlap the position, or it may end entirely before the - // position. If it overlaps with the position, then either it, or one of its - // children must be the nearest node before the position. So we can just - // recurse into this child to see if we can find something better. if (position < child.end) { - // The nearest node is either this child, or one of the children inside - // of it. We've already marked this child as the best so far. Recurse - // in case one of the children is better. forEachChild(child, visit); - // Once we look at the children of this node, then there's no need to - // continue any further. return true; } else { ts.Debug.assert(child.end <= position); - // The child ends entirely before this position. Say you have the following - // (where $ is the position) - // - // ? $ : <...> <...> - // - // We would want to find the nearest preceding node in "complex expr 2". - // To support that, we keep track of this node, and once we're done searching - // for a best node, we recurse down this node to see if we can find a good - // result in it. - // - // This approach allows us to quickly skip over nodes that are entirely - // before the position, while still allowing us to find any nodes in the - // last one that might be what we want. lastNodeEntirelyBeforePosition = child; } } else { ts.Debug.assert(child.pos > position); - // We're now at a node that is entirely past the position we're searching for. - // This node (and all following nodes) could never contribute to the result, - // so just skip them by returning 'true' here. return true; } } @@ -10414,7 +8304,7 @@ var ts; var oldText = sourceFile.text; if (textChangeRange) { ts.Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length); - if (aggressiveChecks || ts.Debug.shouldAssert(3 /* VeryAggressive */)) { + if (aggressiveChecks || ts.Debug.shouldAssert(3)) { var oldTextPrefix = oldText.substr(0, textChangeRange.span.start); var newTextPrefix = newText.substr(0, textChangeRange.span.start); ts.Debug.assert(oldTextPrefix === newTextPrefix); @@ -10429,68 +8319,42 @@ var ts; var currentArrayIndex = 0; ts.Debug.assert(currentArrayIndex < currentArray.length); var current = currentArray[currentArrayIndex]; - var lastQueriedPosition = -1 /* Value */; + var lastQueriedPosition = -1; return { currentNode: function (position) { - // Only compute the current node if the position is different than the last time - // we were asked. The parser commonly asks for the node at the same position - // twice. Once to know if can read an appropriate list element at a certain point, - // and then to actually read and consume the node. if (position !== lastQueriedPosition) { - // Much of the time the parser will need the very next node in the array that - // we just returned a node from.So just simply check for that case and move - // forward in the array instead of searching for the node again. if (current && current.end === position && currentArrayIndex < (currentArray.length - 1)) { currentArrayIndex++; current = currentArray[currentArrayIndex]; } - // If we don't have a node, or the node we have isn't in the right position, - // then try to find a viable node at the position requested. if (!current || current.pos !== position) { findHighestListElementThatStartsAtPosition(position); } } - // Cache this query so that we don't do any extra work if the parser calls back - // into us. Note: this is very common as the parser will make pairs of calls like - // 'isListElement -> parseListElement'. If we were unable to find a node when - // called with 'isListElement', we don't want to redo the work when parseListElement - // is called immediately after. lastQueriedPosition = position; - // Either we don'd have a node, or we have a node at the position being asked for. ts.Debug.assert(!current || current.pos === position); return current; } }; - // Finds the highest element in the tree we can find that starts at the provided position. - // The element must be a direct child of some node list in the tree. This way after we - // return it, we can easily return its next sibling in the list. function findHighestListElementThatStartsAtPosition(position) { - // Clear out any cached state about the last node we found. currentArray = undefined; - currentArrayIndex = -1 /* Value */; + currentArrayIndex = -1; current = undefined; - // Recurse into the source file to find the highest node at this position. forEachChild(sourceFile, visitNode, visitArray); return; function visitNode(node) { if (position >= node.pos && position < node.end) { - // Position was within this node. Keep searching deeper to find the node. forEachChild(node, visitNode, visitArray); - // don't procede any futher in the search. return true; } - // position wasn't in this node, have to keep searching. return false; } function visitArray(array) { if (position >= array.pos && position < array.end) { - // position was in this array. Search through this array to see if we find a - // viable element. for (var i = 0, n = array.length; i < n; i++) { var child = array[i]; if (child) { if (child.pos === position) { - // Found the right node. We're done. currentArray = array; currentArrayIndex = i; current = child; @@ -10498,8 +8362,6 @@ var ts; } else { if (child.pos < position && position < child.end) { - // Position in somewhere within this child. Search in it and - // stop searching in this array. forEachChild(child, visitNode, visitArray); return true; } @@ -10507,64 +8369,47 @@ var ts; } } } - // position wasn't in this array, have to keep searching. return false; } } } - var InvalidPosition; - (function (InvalidPosition) { - InvalidPosition[InvalidPosition["Value"] = -1] = "Value"; - })(InvalidPosition || (InvalidPosition = {})); })(IncrementalParser || (IncrementalParser = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { ts.bindTime = 0; - (function (ModuleInstanceState) { - ModuleInstanceState[ModuleInstanceState["NonInstantiated"] = 0] = "NonInstantiated"; - ModuleInstanceState[ModuleInstanceState["Instantiated"] = 1] = "Instantiated"; - ModuleInstanceState[ModuleInstanceState["ConstEnumOnly"] = 2] = "ConstEnumOnly"; - })(ts.ModuleInstanceState || (ts.ModuleInstanceState = {})); - var ModuleInstanceState = ts.ModuleInstanceState; function getModuleInstanceState(node) { - // A module is uninstantiated if it contains only - // 1. interface declarations, type alias declarations - if (node.kind === 203 /* InterfaceDeclaration */ || node.kind === 204 /* TypeAliasDeclaration */) { - return 0 /* NonInstantiated */; + if (node.kind === 203 || node.kind === 204) { + return 0; } else if (ts.isConstEnumDeclaration(node)) { - return 2 /* ConstEnumOnly */; + return 2; } - else if ((node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) { - return 0 /* NonInstantiated */; + else if ((node.kind === 210 || node.kind === 209) && !(node.flags & 1)) { + return 0; } - else if (node.kind === 207 /* ModuleBlock */) { - var state = 0 /* NonInstantiated */; + else if (node.kind === 207) { + var state = 0; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { - case 0 /* NonInstantiated */: - // child is non-instantiated - continue searching + case 0: return false; - case 2 /* ConstEnumOnly */: - // child is const enum only - record state and continue searching - state = 2 /* ConstEnumOnly */; + case 2: + state = 2; return false; - case 1 /* Instantiated */: - // child is instantiated - record state and stop - state = 1 /* Instantiated */; + case 1: + state = 1; return true; } }); return state; } - else if (node.kind === 206 /* ModuleDeclaration */) { + else if (node.kind === 206) { return getModuleInstanceState(node.body); } else { - return 1 /* Instantiated */; + return 1; } } ts.getModuleInstanceState = getModuleInstanceState; @@ -10603,22 +8448,20 @@ var ts; if (!symbol.declarations) symbol.declarations = []; symbol.declarations.push(node); - if (symbolKind & 1952 /* HasExports */ && !symbol.exports) + if (symbolKind & 1952 && !symbol.exports) symbol.exports = {}; - if (symbolKind & 6240 /* HasMembers */ && !symbol.members) + if (symbolKind & 6240 && !symbol.members) symbol.members = {}; node.symbol = symbol; - if (symbolKind & 107455 /* Value */ && !symbol.valueDeclaration) + if (symbolKind & 107455 && !symbol.valueDeclaration) symbol.valueDeclaration = node; } - // Should not be called on a declaration with a computed property name, - // unless it is a well known Symbol. function getDeclarationName(node) { if (node.name) { - if (node.kind === 206 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */) { + if (node.kind === 206 && node.name.kind === 8) { return '"' + node.name.text + '"'; } - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 128) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -10626,23 +8469,23 @@ var ts; return node.name.text; } switch (node.kind) { - case 144 /* ConstructorType */: - case 136 /* Constructor */: + case 144: + case 136: return "__constructor"; - case 143 /* FunctionType */: - case 139 /* CallSignature */: + case 143: + case 139: return "__call"; - case 140 /* ConstructSignature */: + case 140: return "__new"; - case 141 /* IndexSignature */: + case 141: return "__index"; - case 216 /* ExportDeclaration */: + case 216: return "__export"; - case 215 /* ExportAssignment */: + case 215: return node.isExportEquals ? "export=" : "default"; - case 201 /* FunctionDeclaration */: - case 202 /* ClassDeclaration */: - return node.flags & 256 /* Default */ ? "default" : undefined; + case 201: + case 202: + return node.flags & 256 ? "default" : undefined; } } function getDisplayName(node) { @@ -10650,8 +8493,7 @@ var ts; } function declareSymbol(symbols, parent, node, includes, excludes) { ts.Debug.assert(!ts.hasDynamicName(node)); - // The exported symbol for an export default function/class node is always named "default" - var name = node.flags & 256 /* Default */ && parent ? "default" : getDeclarationName(node); + var name = node.flags & 256 && parent ? "default" : getDeclarationName(node); var symbol; if (name !== undefined) { symbol = ts.hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name)); @@ -10659,9 +8501,7 @@ var ts; if (node.name) { node.name.parent = node; } - // Report errors every position with duplicate declaration - // Report errors on previous encountered declarations - var message = symbol.flags & 2 /* BlockScopedVariable */ + var message = symbol.flags & 2 ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0; ts.forEach(symbol.declarations, function (declaration) { @@ -10676,12 +8516,8 @@ var ts; } addDeclarationToSymbol(symbol, node, includes); symbol.parent = parent; - if ((node.kind === 202 /* ClassDeclaration */ || node.kind === 175 /* ClassExpression */) && symbol.exports) { - // TypeScript 1.0 spec (April 2014): 8.4 - // Every class automatically contains a static property member named 'prototype', - // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter. - // It is an error to explicitly declare a static property member with the name 'prototype'. - var prototypeSymbol = createSymbol(4 /* Property */ | 134217728 /* Prototype */, "prototype"); + if ((node.kind === 202 || node.kind === 175) && symbol.exports) { + var prototypeSymbol = createSymbol(4 | 134217728, "prototype"); if (ts.hasProperty(symbol.exports, prototypeSymbol.name)) { if (node.name) { node.name.parent = node; @@ -10694,9 +8530,9 @@ var ts; return symbol; } function declareModuleMember(node, symbolKind, symbolExcludes) { - var hasExportModifier = ts.getCombinedNodeFlags(node) & 1 /* Export */; - if (symbolKind & 8388608 /* Alias */) { - if (node.kind === 218 /* ExportSpecifier */ || (node.kind === 209 /* ImportEqualsDeclaration */ && hasExportModifier)) { + var hasExportModifier = ts.getCombinedNodeFlags(node) & 1; + if (symbolKind & 8388608) { + if (node.kind === 218 || (node.kind === 209 && hasExportModifier)) { declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); } else { @@ -10704,21 +8540,10 @@ var ts; } } else { - // Exported module members are given 2 symbols: A local symbol that is classified with an ExportValue, - // ExportType, or ExportContainer flag, and an associated export symbol with all the correct flags set - // on it. There are 2 main reasons: - // - // 1. We treat locals and exports of the same name as mutually exclusive within a container. - // That means the binder will issue a Duplicate Identifier error if you mix locals and exports - // with the same name in the same container. - // TODO: Make this a more specific error and decouple it from the exclusion logic. - // 2. When we checkIdentifier in the checker, we set its resolved symbol to the local symbol, - // but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way - // when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope. - if (hasExportModifier || container.flags & 65536 /* ExportContext */) { - var exportKind = (symbolKind & 107455 /* Value */ ? 1048576 /* ExportValue */ : 0) | - (symbolKind & 793056 /* Type */ ? 2097152 /* ExportType */ : 0) | - (symbolKind & 1536 /* Namespace */ ? 4194304 /* ExportNamespace */ : 0); + if (hasExportModifier || container.flags & 65536) { + var exportKind = (symbolKind & 107455 ? 1048576 : 0) | + (symbolKind & 793056 ? 2097152 : 0) | + (symbolKind & 1536 ? 4194304 : 0); var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes); local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); node.localSymbol = local; @@ -10728,28 +8553,20 @@ var ts; } } } - // All container nodes are kept on a linked list in declaration order. This list is used by the getLocalNameOfContainer function - // in the type checker to validate that the local name used for a container is unique. function bindChildren(node, symbolKind, isBlockScopeContainer) { - if (symbolKind & 255504 /* HasLocals */) { + if (symbolKind & 255504) { node.locals = {}; } var saveParent = parent; var saveContainer = container; var savedBlockScopeContainer = blockScopeContainer; parent = node; - if (symbolKind & 262128 /* IsContainer */) { + if (symbolKind & 262128) { container = node; addToContainerChain(container); } if (isBlockScopeContainer) { - // in incremental scenarios we might reuse nodes that already have locals being allocated - // during the bind step these locals should be dropped to prevent using stale data. - // locals should always be dropped unless they were previously initialized by the binder - // these cases are: - // - node has locals (symbolKind & HasLocals) !== 0 - // - node is a source file - setBlockScopeContainer(node, (symbolKind & 255504 /* HasLocals */) === 0 && node.kind !== 228 /* SourceFile */); + setBlockScopeContainer(node, (symbolKind & 255504) === 0 && node.kind !== 228); } ts.forEachChild(node, bind); container = saveContainer; @@ -10764,41 +8581,41 @@ var ts; } function bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer) { switch (container.kind) { - case 206 /* ModuleDeclaration */: + case 206: declareModuleMember(node, symbolKind, symbolExcludes); break; - case 228 /* SourceFile */: + case 228: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolKind, symbolExcludes); break; } - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 143: + case 144: + case 139: + case 140: + case 141: + case 135: + case 134: + case 136: + case 137: + case 138: + case 201: + case 163: + case 164: declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); break; - case 175 /* ClassExpression */: - case 202 /* ClassDeclaration */: - if (node.flags & 128 /* Static */) { + case 175: + case 202: + if (node.flags & 128) { declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } - case 146 /* TypeLiteral */: - case 155 /* ObjectLiteralExpression */: - case 203 /* InterfaceDeclaration */: + case 146: + case 155: + case 203: declareSymbol(container.symbol.members, container.symbol, node, symbolKind, symbolExcludes); break; - case 205 /* EnumDeclaration */: + case 205: declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } @@ -10806,18 +8623,18 @@ var ts; } function isAmbientContext(node) { while (node) { - if (node.flags & 2 /* Ambient */) + if (node.flags & 2) return true; node = node.parent; } return false; } function hasExportDeclarations(node) { - var body = node.kind === 228 /* SourceFile */ ? node : node.body; - if (body.kind === 228 /* SourceFile */ || body.kind === 207 /* ModuleBlock */) { + var body = node.kind === 228 ? node : node.body; + if (body.kind === 228 || body.kind === 207) { for (var _i = 0, _a = body.statements; _i < _a.length; _i++) { var stat = _a[_i]; - if (stat.kind === 216 /* ExportDeclaration */ || stat.kind === 215 /* ExportAssignment */) { + if (stat.kind === 216 || stat.kind === 215) { return true; } } @@ -10825,34 +8642,30 @@ var ts; return false; } function setExportContextFlag(node) { - // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular - // declarations with export modifiers) is an export context in which declarations are implicitly exported. if (isAmbientContext(node) && !hasExportDeclarations(node)) { - node.flags |= 65536 /* ExportContext */; + node.flags |= 65536; } else { - node.flags &= ~65536 /* ExportContext */; + node.flags &= ~65536; } } function bindModuleDeclaration(node) { setExportContextFlag(node); - if (node.name.kind === 8 /* StringLiteral */) { - bindDeclaration(node, 512 /* ValueModule */, 106639 /* ValueModuleExcludes */, true); + if (node.name.kind === 8) { + bindDeclaration(node, 512, 106639, true); } else { var state = getModuleInstanceState(node); - if (state === 0 /* NonInstantiated */) { - bindDeclaration(node, 1024 /* NamespaceModule */, 0 /* NamespaceModuleExcludes */, true); + if (state === 0) { + bindDeclaration(node, 1024, 0, true); } else { - bindDeclaration(node, 512 /* ValueModule */, 106639 /* ValueModuleExcludes */, true); - var currentModuleIsConstEnumOnly = state === 2 /* ConstEnumOnly */; + bindDeclaration(node, 512, 106639, true); + var currentModuleIsConstEnumOnly = state === 2; if (node.symbol.constEnumOnlyModule === undefined) { - // non-merged case - use the current state node.symbol.constEnumOnlyModule = currentModuleIsConstEnumOnly; } else { - // merged case: module is const enum only if all its pieces are non-instantiated or const enum node.symbol.constEnumOnlyModule = node.symbol.constEnumOnlyModule && currentModuleIsConstEnumOnly; } } @@ -10865,13 +8678,13 @@ var ts; // We do that by making an anonymous type literal symbol, and then setting the function // symbol as its sole member. To the rest of the system, this symbol will be indistinguishable // from an actual type literal symbol you would have gotten had you used the long form. - var symbol = createSymbol(131072 /* Signature */, getDeclarationName(node)); - addDeclarationToSymbol(symbol, node, 131072 /* Signature */); - bindChildren(node, 131072 /* Signature */, false); - var typeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type"); - addDeclarationToSymbol(typeLiteralSymbol, node, 2048 /* TypeLiteral */); + var symbol = createSymbol(131072, getDeclarationName(node)); + addDeclarationToSymbol(symbol, node, 131072); + bindChildren(node, 131072, false); + var typeLiteralSymbol = createSymbol(2048, "__type"); + addDeclarationToSymbol(typeLiteralSymbol, node, 2048); typeLiteralSymbol.members = {}; - typeLiteralSymbol.members[node.kind === 143 /* FunctionType */ ? "__call" : "__new"] = symbol; + typeLiteralSymbol.members[node.kind === 143 ? "__call" : "__new"] = symbol; } function bindAnonymousDeclaration(node, symbolKind, name, isBlockScopeContainer) { var symbol = createSymbol(symbolKind, name); @@ -10883,15 +8696,14 @@ var ts; } function bindBlockScopedDeclaration(node, symbolKind, symbolExcludes) { switch (blockScopeContainer.kind) { - case 206 /* ModuleDeclaration */: + case 206: declareModuleMember(node, symbolKind, symbolExcludes); break; - case 228 /* SourceFile */: + case 228: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolKind, symbolExcludes); break; } - // fall through. default: if (!blockScopeContainer.locals) { blockScopeContainer.locals = {}; @@ -10902,7 +8714,7 @@ var ts; bindChildren(node, symbolKind, false); } function bindBlockScopedVariableDeclaration(node) { - bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 107455 /* BlockScopedVariableExcludes */); + bindBlockScopedDeclaration(node, 2, 107455); } function getDestructuringParameterName(node) { return "__" + ts.indexOf(node.parent.parameters, node); @@ -10910,14 +8722,14 @@ var ts; function bind(node) { node.parent = parent; switch (node.kind) { - case 129 /* TypeParameter */: - bindDeclaration(node, 262144 /* TypeParameter */, 530912 /* TypeParameterExcludes */, false); + case 129: + bindDeclaration(node, 262144, 530912, false); break; - case 130 /* Parameter */: + case 130: bindParameter(node); break; - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 199: + case 153: if (ts.isBindingPattern(node.name)) { bindChildren(node, 0, false); } @@ -10925,139 +8737,124 @@ var ts; bindBlockScopedVariableDeclaration(node); } else { - bindDeclaration(node, 1 /* FunctionScopedVariable */, 107454 /* FunctionScopedVariableExcludes */, false); + bindDeclaration(node, 1, 107454, false); } break; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - bindPropertyOrMethodOrAccessor(node, 4 /* Property */ | (node.questionToken ? 536870912 /* Optional */ : 0), 107455 /* PropertyExcludes */, false); + case 133: + case 132: + bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); break; - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - bindPropertyOrMethodOrAccessor(node, 4 /* Property */, 107455 /* PropertyExcludes */, false); + case 225: + case 226: + bindPropertyOrMethodOrAccessor(node, 4, 107455, false); break; - case 227 /* EnumMember */: - bindPropertyOrMethodOrAccessor(node, 8 /* EnumMember */, 107455 /* EnumMemberExcludes */, false); + case 227: + bindPropertyOrMethodOrAccessor(node, 8, 107455, false); break; - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - bindDeclaration(node, 131072 /* Signature */, 0, false); + case 139: + case 140: + case 141: + bindDeclaration(node, 131072, 0, false); break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - // If this is an ObjectLiteralExpression method, then it sits in the same space - // as other properties in the object literal. So we use SymbolFlags.PropertyExcludes - // so that it will conflict with any other object literal members with the same - // name. - bindPropertyOrMethodOrAccessor(node, 8192 /* Method */ | (node.questionToken ? 536870912 /* Optional */ : 0), ts.isObjectLiteralMethod(node) ? 107455 /* PropertyExcludes */ : 99263 /* MethodExcludes */, true); + case 135: + case 134: + bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); break; - case 201 /* FunctionDeclaration */: - bindDeclaration(node, 16 /* Function */, 106927 /* FunctionExcludes */, true); + case 201: + bindDeclaration(node, 16, 106927, true); break; - case 136 /* Constructor */: - bindDeclaration(node, 16384 /* Constructor */, 0, true); + case 136: + bindDeclaration(node, 16384, 0, true); break; - case 137 /* GetAccessor */: - bindPropertyOrMethodOrAccessor(node, 32768 /* GetAccessor */, 41919 /* GetAccessorExcludes */, true); + case 137: + bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); break; - case 138 /* SetAccessor */: - bindPropertyOrMethodOrAccessor(node, 65536 /* SetAccessor */, 74687 /* SetAccessorExcludes */, true); + case 138: + bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); break; - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 143: + case 144: bindFunctionOrConstructorType(node); break; - case 146 /* TypeLiteral */: - bindAnonymousDeclaration(node, 2048 /* TypeLiteral */, "__type", false); + case 146: + bindAnonymousDeclaration(node, 2048, "__type", false); break; - case 155 /* ObjectLiteralExpression */: - bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object", false); + case 155: + bindAnonymousDeclaration(node, 4096, "__object", false); break; - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - bindAnonymousDeclaration(node, 16 /* Function */, "__function", true); + case 163: + case 164: + bindAnonymousDeclaration(node, 16, "__function", true); break; - case 175 /* ClassExpression */: - bindAnonymousDeclaration(node, 32 /* Class */, "__class", false); + case 175: + bindAnonymousDeclaration(node, 32, "__class", false); break; - case 224 /* CatchClause */: + case 224: bindCatchVariableDeclaration(node); break; - case 202 /* ClassDeclaration */: - bindBlockScopedDeclaration(node, 32 /* Class */, 899583 /* ClassExcludes */); + case 202: + bindBlockScopedDeclaration(node, 32, 899583); break; - case 203 /* InterfaceDeclaration */: - bindDeclaration(node, 64 /* Interface */, 792992 /* InterfaceExcludes */, false); + case 203: + bindDeclaration(node, 64, 792992, false); break; - case 204 /* TypeAliasDeclaration */: - bindDeclaration(node, 524288 /* TypeAlias */, 793056 /* TypeAliasExcludes */, false); + case 204: + bindDeclaration(node, 524288, 793056, false); break; - case 205 /* EnumDeclaration */: + case 205: if (ts.isConst(node)) { - bindDeclaration(node, 128 /* ConstEnum */, 899967 /* ConstEnumExcludes */, false); + bindDeclaration(node, 128, 899967, false); } else { - bindDeclaration(node, 256 /* RegularEnum */, 899327 /* RegularEnumExcludes */, false); + bindDeclaration(node, 256, 899327, false); } break; - case 206 /* ModuleDeclaration */: + case 206: bindModuleDeclaration(node); break; - case 209 /* ImportEqualsDeclaration */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: - bindDeclaration(node, 8388608 /* Alias */, 8388608 /* AliasExcludes */, false); + case 209: + case 212: + case 214: + case 218: + bindDeclaration(node, 8388608, 8388608, false); break; - case 211 /* ImportClause */: + case 211: if (node.name) { - bindDeclaration(node, 8388608 /* Alias */, 8388608 /* AliasExcludes */, false); + bindDeclaration(node, 8388608, 8388608, false); } else { bindChildren(node, 0, false); } break; - case 216 /* ExportDeclaration */: + case 216: if (!node.exportClause) { - // All export * declarations are collected in an __export symbol - declareSymbol(container.symbol.exports, container.symbol, node, 1073741824 /* ExportStar */, 0); + declareSymbol(container.symbol.exports, container.symbol, node, 1073741824, 0); } bindChildren(node, 0, false); break; - case 215 /* ExportAssignment */: - if (node.expression.kind === 65 /* Identifier */) { - // An export default clause with an identifier exports all meanings of that identifier - declareSymbol(container.symbol.exports, container.symbol, node, 8388608 /* Alias */, 107455 /* PropertyExcludes */ | 8388608 /* AliasExcludes */); + case 215: + if (node.expression.kind === 65) { + declareSymbol(container.symbol.exports, container.symbol, node, 8388608, 107455 | 8388608); } else { - // An export default clause with an expression exports a value - declareSymbol(container.symbol.exports, container.symbol, node, 4 /* Property */, 107455 /* PropertyExcludes */ | 8388608 /* AliasExcludes */); + declareSymbol(container.symbol.exports, container.symbol, node, 4, 107455 | 8388608); } bindChildren(node, 0, false); break; - case 228 /* SourceFile */: + case 228: setExportContextFlag(node); if (ts.isExternalModule(node)) { - bindAnonymousDeclaration(node, 512 /* ValueModule */, '"' + ts.removeFileExtension(node.fileName) + '"', true); + bindAnonymousDeclaration(node, 512, '"' + ts.removeFileExtension(node.fileName) + '"', true); break; } - case 180 /* Block */: - // do not treat function block a block-scope container - // all block-scope locals that reside in this block should go to the function locals. - // Otherwise this won't be considered as redeclaration of a block scoped local: - // function foo() { - // let x; - // let x; - // } - // 'let x' will be placed into the function locals and 'let x' - into the locals of the block + case 180: bindChildren(node, 0, !ts.isFunctionLike(node.parent)); break; - case 224 /* CatchClause */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 208 /* CaseBlock */: + case 224: + case 187: + case 188: + case 189: + case 208: bindChildren(node, 0, true); break; default: @@ -11069,18 +8866,16 @@ var ts; } function bindParameter(node) { if (ts.isBindingPattern(node.name)) { - bindAnonymousDeclaration(node, 1 /* FunctionScopedVariable */, getDestructuringParameterName(node), false); + bindAnonymousDeclaration(node, 1, getDestructuringParameterName(node), false); } else { - bindDeclaration(node, 1 /* FunctionScopedVariable */, 107455 /* ParameterExcludes */, false); + bindDeclaration(node, 1, 107455, false); } - // If this is a property-parameter, then also declare the property symbol into the - // containing class. - if (node.flags & 112 /* AccessibilityModifier */ && - node.parent.kind === 136 /* Constructor */ && - (node.parent.parent.kind === 202 /* ClassDeclaration */ || node.parent.parent.kind === 175 /* ClassExpression */)) { + if (node.flags & 112 && + node.parent.kind === 136 && + (node.parent.parent.kind === 202 || node.parent.parent.kind === 175)) { var classDeclaration = node.parent.parent; - declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */, 107455 /* PropertyExcludes */); + declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } } function bindPropertyOrMethodOrAccessor(node, symbolKind, symbolExcludes, isBlockScopeContainer) { @@ -11094,7 +8889,6 @@ var ts; } })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var nextSymbolId = 1; @@ -11122,10 +8916,10 @@ var ts; var emptyArray = []; var emptySymbols = {}; var compilerOptions = host.getCompilerOptions(); - var languageVersion = compilerOptions.target || 0 /* ES3 */; + var languageVersion = compilerOptions.target || 0; var emitResolver = createResolver(); - var undefinedSymbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "undefined"); - var argumentsSymbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "arguments"); + var undefinedSymbol = createSymbol(4 | 67108864, "undefined"); + var argumentsSymbol = createSymbol(4 | 67108864, "arguments"); var checker = { getNodeCount: function () { return ts.sum(host.getSourceFiles(), "nodeCount"); }, getIdentifierCount: function () { return ts.sum(host.getSourceFiles(), "identifierCount"); }, @@ -11162,18 +8956,18 @@ var ts; getEmitResolver: getEmitResolver, getExportsOfModule: getExportsOfModuleAsArray }; - var unknownSymbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "unknown"); - var resolvingSymbol = createSymbol(67108864 /* Transient */, "__resolving__"); - var anyType = createIntrinsicType(1 /* Any */, "any"); - var stringType = createIntrinsicType(2 /* String */, "string"); - var numberType = createIntrinsicType(4 /* Number */, "number"); - var booleanType = createIntrinsicType(8 /* Boolean */, "boolean"); - var esSymbolType = createIntrinsicType(1048576 /* ESSymbol */, "symbol"); - var voidType = createIntrinsicType(16 /* Void */, "void"); - var undefinedType = createIntrinsicType(32 /* Undefined */ | 262144 /* ContainsUndefinedOrNull */, "undefined"); - var nullType = createIntrinsicType(64 /* Null */ | 262144 /* ContainsUndefinedOrNull */, "null"); - var unknownType = createIntrinsicType(1 /* Any */, "unknown"); - var resolvingType = createIntrinsicType(1 /* Any */, "__resolving__"); + var unknownSymbol = createSymbol(4 | 67108864, "unknown"); + var resolvingSymbol = createSymbol(67108864, "__resolving__"); + var anyType = createIntrinsicType(1, "any"); + var stringType = createIntrinsicType(2, "string"); + var numberType = createIntrinsicType(4, "number"); + var booleanType = createIntrinsicType(8, "boolean"); + var esSymbolType = createIntrinsicType(1048576, "symbol"); + var voidType = createIntrinsicType(16, "void"); + var undefinedType = createIntrinsicType(32 | 262144, "undefined"); + var nullType = createIntrinsicType(64 | 262144, "null"); + var unknownType = createIntrinsicType(1, "unknown"); + var resolvingType = createIntrinsicType(1, "__resolving__"); var emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); @@ -11211,24 +9005,22 @@ var ts; var primitiveTypeInfo = { "string": { type: stringType, - flags: 258 /* StringLike */ + flags: 258 }, "number": { type: numberType, - flags: 132 /* NumberLike */ + flags: 132 }, "boolean": { type: booleanType, - flags: 8 /* Boolean */ + flags: 8 }, "symbol": { type: esSymbolType, - flags: 1048576 /* ESSymbol */ + flags: 1048576 } }; function getEmitResolver(sourceFile) { - // Ensure we have all the type information in place for this file so that all the - // emitter questions of this resolver will return the right information. getDiagnostics(sourceFile); return emitResolver; } @@ -11243,38 +9035,38 @@ var ts; } function getExcludedSymbolFlags(flags) { var result = 0; - if (flags & 2 /* BlockScopedVariable */) - result |= 107455 /* BlockScopedVariableExcludes */; - if (flags & 1 /* FunctionScopedVariable */) - result |= 107454 /* FunctionScopedVariableExcludes */; - if (flags & 4 /* Property */) - result |= 107455 /* PropertyExcludes */; - if (flags & 8 /* EnumMember */) - result |= 107455 /* EnumMemberExcludes */; - if (flags & 16 /* Function */) - result |= 106927 /* FunctionExcludes */; - if (flags & 32 /* Class */) - result |= 899583 /* ClassExcludes */; - if (flags & 64 /* Interface */) - result |= 792992 /* InterfaceExcludes */; - if (flags & 256 /* RegularEnum */) - result |= 899327 /* RegularEnumExcludes */; - if (flags & 128 /* ConstEnum */) - result |= 899967 /* ConstEnumExcludes */; - if (flags & 512 /* ValueModule */) - result |= 106639 /* ValueModuleExcludes */; - if (flags & 8192 /* Method */) - result |= 99263 /* MethodExcludes */; - if (flags & 32768 /* GetAccessor */) - result |= 41919 /* GetAccessorExcludes */; - if (flags & 65536 /* SetAccessor */) - result |= 74687 /* SetAccessorExcludes */; - if (flags & 262144 /* TypeParameter */) - result |= 530912 /* TypeParameterExcludes */; - if (flags & 524288 /* TypeAlias */) - result |= 793056 /* TypeAliasExcludes */; - if (flags & 8388608 /* Alias */) - result |= 8388608 /* AliasExcludes */; + if (flags & 2) + result |= 107455; + if (flags & 1) + result |= 107454; + if (flags & 4) + result |= 107455; + if (flags & 8) + result |= 107455; + if (flags & 16) + result |= 106927; + if (flags & 32) + result |= 899583; + if (flags & 64) + result |= 792992; + if (flags & 256) + result |= 899327; + if (flags & 128) + result |= 899967; + if (flags & 512) + result |= 106639; + if (flags & 8192) + result |= 99263; + if (flags & 32768) + result |= 41919; + if (flags & 65536) + result |= 74687; + if (flags & 262144) + result |= 530912; + if (flags & 524288) + result |= 793056; + if (flags & 8388608) + result |= 8388608; return result; } function recordMergedSymbol(target, source) { @@ -11283,7 +9075,7 @@ var ts; mergedSymbols[source.mergeId] = target; } function cloneSymbol(symbol) { - var result = createSymbol(symbol.flags | 33554432 /* Merged */, symbol.name); + var result = createSymbol(symbol.flags | 33554432, symbol.name); result.declarations = symbol.declarations.slice(0); result.parent = symbol.parent; if (symbol.valueDeclaration) @@ -11299,8 +9091,7 @@ var ts; } function mergeSymbol(target, source) { if (!(target.flags & getExcludedSymbolFlags(source.flags))) { - if (source.flags & 512 /* ValueModule */ && target.flags & 512 /* ValueModule */ && target.constEnumOnlyModule && !source.constEnumOnlyModule) { - // reset flag when merging instantiated module into value module that has only const enums + if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) { target.constEnumOnlyModule = false; } target.flags |= source.flags; @@ -11322,7 +9113,7 @@ var ts; recordMergedSymbol(target, source); } else { - var message = target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */ + var message = target.flags & 2 || source.flags & 2 ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0; ts.forEach(source.declarations, function (node) { error(node.name ? node.name : node, message, symbolToString(source)); @@ -11349,7 +9140,7 @@ var ts; } else { var symbol = target[id]; - if (!(symbol.flags & 33554432 /* Merged */)) { + if (!(symbol.flags & 33554432)) { target[id] = symbol = cloneSymbol(symbol); } mergeSymbol(symbol, source[id]); @@ -11358,7 +9149,7 @@ var ts; } } function getSymbolLinks(symbol) { - if (symbol.flags & 67108864 /* Transient */) + if (symbol.flags & 67108864) return symbol; var id = getSymbolId(symbol); return symbolLinks[id] || (symbolLinks[id] = {}); @@ -11368,29 +9159,26 @@ var ts; return nodeLinks[nodeId] || (nodeLinks[nodeId] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 228 /* SourceFile */); + return ts.getAncestor(node, 228); } function isGlobalSourceFile(node) { - return node.kind === 228 /* SourceFile */ && !ts.isExternalModule(node); + return node.kind === 228 && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { var symbol = symbols[name]; - ts.Debug.assert((symbol.flags & 16777216 /* Instantiated */) === 0, "Should never get an instantiated symbol here."); + ts.Debug.assert((symbol.flags & 16777216) === 0, "Should never get an instantiated symbol here."); if (symbol.flags & meaning) { return symbol; } - if (symbol.flags & 8388608 /* Alias */) { + if (symbol.flags & 8388608) { var target = resolveAlias(symbol); - // Unknown symbol means an error occurred in alias resolution, treat it as positive answer to avoid cascading errors if (target === unknownSymbol || target.flags & meaning) { return symbol; } } } - // return undefined if we can't find a symbol. } - /** Returns true if node1 is defined before node 2**/ function isDefinedBefore(node1, node2) { var file1 = ts.getSourceFileOfNode(node1); var file2 = ts.getSourceFileOfNode(node2); @@ -11403,9 +9191,6 @@ var ts; var sourceFiles = host.getSourceFiles(); return sourceFiles.indexOf(file1) <= sourceFiles.indexOf(file2); } - // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and - // the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with - // the given name can be found. function resolveName(location, name, meaning, nameNotFoundMessage, nameArg) { var result; var lastLocation; @@ -11413,26 +9198,25 @@ var ts; var errorLocation = location; var grandparent; loop: while (location) { - // Locals of a source file are not in scope (because they get merged into the global symbol table) if (location.locals && !isGlobalSourceFile(location)) { if (result = getSymbol(location.locals, name, meaning)) { break loop; } } switch (location.kind) { - case 228 /* SourceFile */: + case 228: if (!ts.isExternalModule(location)) break; - case 206 /* ModuleDeclaration */: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931 /* ModuleMember */)) { - if (result.flags & meaning || !(result.flags & 8388608 /* Alias */ && getDeclarationOfAliasSymbol(result).kind === 218 /* ExportSpecifier */)) { + case 206: + if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { + if (result.flags & meaning || !(result.flags & 8388608 && getDeclarationOfAliasSymbol(result).kind === 218)) { break loop; } result = undefined; } - else if (location.kind === 228 /* SourceFile */ || - (location.kind === 206 /* ModuleDeclaration */ && location.name.kind === 8 /* StringLiteral */)) { - result = getSymbol(getSymbolOfNode(location).exports, "default", meaning & 8914931 /* ModuleMember */); + else if (location.kind === 228 || + (location.kind === 206 && location.name.kind === 8)) { + result = getSymbol(getSymbolOfNode(location).exports, "default", meaning & 8914931); var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && (result.flags & meaning) && localSymbol && localSymbol.name === name) { break loop; @@ -11440,73 +9224,54 @@ var ts; result = undefined; } break; - case 205 /* EnumDeclaration */: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) { + case 205: + if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { break loop; } break; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - // TypeScript 1.0 spec (April 2014): 8.4.1 - // Initializer expressions for instance member variables are evaluated in the scope - // of the class constructor body but are not permitted to reference parameters or - // local variables of the constructor. This effectively means that entities from outer scopes - // by the same name as a constructor parameter or local variable are inaccessible - // in initializer expressions for instance member variables. - if (location.parent.kind === 202 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) { + case 133: + case 132: + if (location.parent.kind === 202 && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { - if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) { - // Remember the property node, it will be used later to report appropriate error + if (getSymbol(ctor.locals, name, meaning & 107455)) { propertyWithInvalidInitializer = location; } } } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) { - if (lastLocation && lastLocation.flags & 128 /* Static */) { - // TypeScript 1.0 spec (April 2014): 3.4.1 - // The scope of a type parameter extends over the entire declaration with which the type - // parameter list is associated, with the exception of static member declarations in classes. + case 202: + case 203: + if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056)) { + if (lastLocation && lastLocation.flags & 128) { error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters); return undefined; } break loop; } break; - // It is not legal to reference a class's own type parameters from a computed property name that - // belongs to the class. For example: - // - // function foo() { return '' } - // class C { // <-- Class's own type parameter T - // [foo()]() { } // <-- Reference to T from class's own computed property - // } - // - case 128 /* ComputedPropertyName */: + case 128: grandparent = location.parent.parent; - if (grandparent.kind === 202 /* ClassDeclaration */ || grandparent.kind === 203 /* InterfaceDeclaration */) { - // A reference to this grandparent's type parameters would be an error - if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056 /* Type */)) { + if (grandparent.kind === 202 || grandparent.kind === 203) { + if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); return undefined; } } break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: + case 135: + case 134: + case 136: + case 137: + case 138: + case 201: + case 164: if (name === "arguments") { result = argumentsSymbol; break loop; } break; - case 163 /* FunctionExpression */: + case 163: if (name === "arguments") { result = argumentsSymbol; break loop; @@ -11517,31 +9282,17 @@ var ts; break loop; } break; - case 175 /* ClassExpression */: + case 175: var className = location.name; if (className && name === className.text) { result = location.symbol; break loop; } break; - case 131 /* Decorator */: - // Decorators are resolved at the class declaration. Resolving at the parameter - // or member would result in looking up locals in the method. - // - // function y() {} - // class C { - // method(@y x, y) {} // <-- decorator y should be resolved at the class declaration, not the parameter. - // } - // - if (location.parent && location.parent.kind === 130 /* Parameter */) { + case 131: + if (location.parent && location.parent.kind === 130) { location = location.parent; } - // - // function y() {} - // class C { - // @y method(x, y) {} // <-- decorator y should be resolved at the class declaration, not the method. - // } - // if (location.parent && ts.isClassElement(location.parent)) { location = location.parent; } @@ -11559,47 +9310,32 @@ var ts; } return undefined; } - // Perform extra checks only if error reporting was requested if (nameNotFoundMessage) { if (propertyWithInvalidInitializer) { - // We have a match, but the reference occurred within a property initializer and the identifier also binds - // to a local variable in the constructor where the code will be emitted. var propertyName = propertyWithInvalidInitializer.name; error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), typeof nameArg === "string" ? nameArg : ts.declarationNameToString(nameArg)); return undefined; } - if (result.flags & 2 /* BlockScopedVariable */) { + if (result.flags & 2) { checkResolvedBlockScopedVariable(result, errorLocation); } } return result; } function checkResolvedBlockScopedVariable(result, errorLocation) { - ts.Debug.assert((result.flags & 2 /* BlockScopedVariable */) !== 0); - // Block-scoped variables cannot be used before their definition + ts.Debug.assert((result.flags & 2) !== 0); var declaration = ts.forEach(result.declarations, function (d) { return ts.isBlockOrCatchScoped(d) ? d : undefined; }); ts.Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined"); - // first check if usage is lexically located after the declaration var isUsedBeforeDeclaration = !isDefinedBefore(declaration, errorLocation); if (!isUsedBeforeDeclaration) { - // lexical check succeeded however code still can be illegal. - // - block scoped variables cannot be used in its initializers - // let x = x; // illegal but usage is lexically after definition - // - in ForIn/ForOf statements variable cannot be contained in expression part - // for (let x in x) - // for (let x of x) - // climb up to the variable declaration skipping binding patterns - var variableDeclaration = ts.getAncestor(declaration, 199 /* VariableDeclaration */); + var variableDeclaration = ts.getAncestor(declaration, 199); var container = ts.getEnclosingBlockScopeContainer(variableDeclaration); - if (variableDeclaration.parent.parent.kind === 181 /* VariableStatement */ || - variableDeclaration.parent.parent.kind === 187 /* ForStatement */) { - // variable statement/for statement case, - // use site should not be inside variable declaration (initializer of declaration or binding element) + if (variableDeclaration.parent.parent.kind === 181 || + variableDeclaration.parent.parent.kind === 187) { isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, variableDeclaration, container); } - else if (variableDeclaration.parent.parent.kind === 189 /* ForOfStatement */ || - variableDeclaration.parent.parent.kind === 188 /* ForInStatement */) { - // ForIn/ForOf case - use site should not be used in expression part + else if (variableDeclaration.parent.parent.kind === 189 || + variableDeclaration.parent.parent.kind === 188) { var expression = variableDeclaration.parent.parent.expression; isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, expression, container); } @@ -11608,10 +9344,6 @@ var ts; error(errorLocation, ts.Diagnostics.Block_scoped_variable_0_used_before_its_declaration, ts.declarationNameToString(declaration.name)); } } - /* Starting from 'initial' node walk up the parent chain until 'stopAt' node is reached. - * If at any point current node is equal to 'parent' node - return true. - * Return false if 'stopAt' node is reached or isFunctionLike(current) === true. - */ function isSameScopeDescendentOf(initial, parent, stopAt) { if (!parent) { return false; @@ -11625,10 +9357,10 @@ var ts; } function getAnyImportSyntax(node) { if (ts.isAliasSymbolDeclaration(node)) { - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 209) { return node; } - while (node && node.kind !== 210 /* ImportDeclaration */) { + while (node && node.kind !== 210) { node = node.parent; } return node; @@ -11638,7 +9370,7 @@ var ts; return ts.forEach(symbol.declarations, function (d) { return ts.isAliasSymbolDeclaration(d) ? d : undefined; }); } function getTargetOfImportEqualsDeclaration(node) { - if (node.moduleReference.kind === 220 /* ExternalModuleReference */) { + if (node.moduleReference.kind === 220) { return resolveExternalModuleSymbol(resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node))); } return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); @@ -11658,33 +9390,15 @@ var ts; return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier); } function getMemberOfModuleVariable(moduleSymbol, name) { - if (moduleSymbol.flags & 3 /* Variable */) { + if (moduleSymbol.flags & 3) { var typeAnnotation = moduleSymbol.valueDeclaration.type; if (typeAnnotation) { return getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name); } } } - // This function creates a synthetic symbol that combines the value side of one symbol with the - // type/namespace side of another symbol. Consider this example: - // - // declare module graphics { - // interface Point { - // x: number; - // y: number; - // } - // } - // declare var graphics: { - // Point: new (x: number, y: number) => graphics.Point; - // } - // declare module "graphics" { - // export = graphics; - // } - // - // An 'import { Point } from "graphics"' needs to create a symbol that combines the value side 'Point' - // property with the type/namespace side interface 'Point'. function combineValueAndTypeSymbols(valueSymbol, typeSymbol) { - if (valueSymbol.flags & (793056 /* Type */ | 1536 /* Namespace */)) { + if (valueSymbol.flags & (793056 | 1536)) { return valueSymbol; } var result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name); @@ -11699,7 +9413,7 @@ var ts; return result; } function getExportOfModule(symbol, name) { - if (symbol.flags & 1536 /* Module */) { + if (symbol.flags & 1536) { var exports_1 = getExportsOfSymbol(symbol); if (ts.hasProperty(exports_1, name)) { return resolveSymbol(exports_1[name]); @@ -11707,7 +9421,7 @@ var ts; } } function getPropertyOfVariable(symbol, name) { - if (symbol.flags & 3 /* Variable */) { + if (symbol.flags & 3) { var typeAnnotation = symbol.valueDeclaration.type; if (typeAnnotation) { return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name)); @@ -11738,32 +9452,32 @@ var ts; function getTargetOfExportSpecifier(node) { return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : - resolveEntityName(node.propertyName || node.name, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */); + resolveEntityName(node.propertyName || node.name, 107455 | 793056 | 1536); } function getTargetOfExportAssignment(node) { - return resolveEntityName(node.expression, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */); + return resolveEntityName(node.expression, 107455 | 793056 | 1536); } function getTargetOfAliasDeclaration(node) { switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: + case 209: return getTargetOfImportEqualsDeclaration(node); - case 211 /* ImportClause */: + case 211: return getTargetOfImportClause(node); - case 212 /* NamespaceImport */: + case 212: return getTargetOfNamespaceImport(node); - case 214 /* ImportSpecifier */: + case 214: return getTargetOfImportSpecifier(node); - case 218 /* ExportSpecifier */: + case 218: return getTargetOfExportSpecifier(node); - case 215 /* ExportAssignment */: + case 215: return getTargetOfExportAssignment(node); } } function resolveSymbol(symbol) { - return symbol && symbol.flags & 8388608 /* Alias */ && !(symbol.flags & (107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */)) ? resolveAlias(symbol) : symbol; + return symbol && symbol.flags & 8388608 && !(symbol.flags & (107455 | 793056 | 1536)) ? resolveAlias(symbol) : symbol; } function resolveAlias(symbol) { - ts.Debug.assert((symbol.flags & 8388608 /* Alias */) !== 0, "Should only get Alias here."); + ts.Debug.assert((symbol.flags & 8388608) !== 0, "Should only get Alias here."); var links = getSymbolLinks(symbol); if (!links.target) { links.target = resolvingSymbol; @@ -11786,79 +9500,62 @@ var ts; var target = resolveAlias(symbol); if (target) { var markAlias = (target === unknownSymbol && compilerOptions.separateCompilation) || - (target !== unknownSymbol && (target.flags & 107455 /* Value */) && !isConstEnumOrConstEnumOnlyModule(target)); + (target !== unknownSymbol && (target.flags & 107455) && !isConstEnumOrConstEnumOnlyModule(target)); if (markAlias) { markAliasSymbolAsReferenced(symbol); } } } - // When an alias symbol is referenced, we need to mark the entity it references as referenced and in turn repeat that until - // we reach a non-alias or an exported entity (which is always considered referenced). We do this by checking the target of - // the alias as an expression (which recursively takes us back here if the target references another alias). function markAliasSymbolAsReferenced(symbol) { var links = getSymbolLinks(symbol); if (!links.referenced) { links.referenced = true; var node = getDeclarationOfAliasSymbol(symbol); - if (node.kind === 215 /* ExportAssignment */) { - // export default + if (node.kind === 215) { checkExpressionCached(node.expression); } - else if (node.kind === 218 /* ExportSpecifier */) { - // export { } or export { as foo } + else if (node.kind === 218) { checkExpressionCached(node.propertyName || node.name); } else if (ts.isInternalModuleImportEqualsDeclaration(node)) { - // import foo = checkExpressionCached(node.moduleReference); } } } - // This function is only for imports with entity names function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 209 /* ImportEqualsDeclaration */); + importDeclaration = ts.getAncestor(entityName, 209); ts.Debug.assert(importDeclaration !== undefined); } - // There are three things we might try to look for. In the following examples, - // the search term is enclosed in |...|: - // - // import a = |b|; // Namespace - // import a = |b.c|; // Value, type, namespace - // import a = |b.c|.d; // Namespace - if (entityName.kind === 65 /* Identifier */ && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { + if (entityName.kind === 65 && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { entityName = entityName.parent; } - // Check for case 1 and 3 in the above example - if (entityName.kind === 65 /* Identifier */ || entityName.parent.kind === 127 /* QualifiedName */) { - return resolveEntityName(entityName, 1536 /* Namespace */); + if (entityName.kind === 65 || entityName.parent.kind === 127) { + return resolveEntityName(entityName, 1536); } else { - // Case 2 in above example - // entityName.kind could be a QualifiedName or a Missing identifier - ts.Debug.assert(entityName.parent.kind === 209 /* ImportEqualsDeclaration */); - return resolveEntityName(entityName, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */); + ts.Debug.assert(entityName.parent.kind === 209); + return resolveEntityName(entityName, 107455 | 793056 | 1536); } } function getFullyQualifiedName(symbol) { return symbol.parent ? getFullyQualifiedName(symbol.parent) + "." + symbolToString(symbol) : symbolToString(symbol); } - // Resolves a qualified name and any involved aliases function resolveEntityName(name, meaning) { if (ts.nodeIsMissing(name)) { return undefined; } var symbol; - if (name.kind === 65 /* Identifier */) { + if (name.kind === 65) { symbol = resolveName(name, name.text, meaning, ts.Diagnostics.Cannot_find_name_0, name); if (!symbol) { return undefined; } } - else if (name.kind === 127 /* QualifiedName */ || name.kind === 156 /* PropertyAccessExpression */) { - var left = name.kind === 127 /* QualifiedName */ ? name.left : name.expression; - var right = name.kind === 127 /* QualifiedName */ ? name.right : name.name; - var namespace = resolveEntityName(left, 1536 /* Namespace */); + else if (name.kind === 127 || name.kind === 156) { + var left = name.kind === 127 ? name.left : name.expression; + var right = name.kind === 127 ? name.right : name.name; + var namespace = resolveEntityName(left, 1536); if (!namespace || namespace === unknownSymbol || ts.nodeIsMissing(right)) { return undefined; } @@ -11871,28 +9568,24 @@ var ts; else { ts.Debug.fail("Unknown entity name kind."); } - ts.Debug.assert((symbol.flags & 16777216 /* Instantiated */) === 0, "Should never get an instantiated symbol here."); + ts.Debug.assert((symbol.flags & 16777216) === 0, "Should never get an instantiated symbol here."); return symbol.flags & meaning ? symbol : resolveAlias(symbol); } function isExternalModuleNameRelative(moduleName) { - // TypeScript 1.0 spec (April 2014): 11.2.1 - // An external module name is "relative" if the first term is "." or "..". return moduleName.substr(0, 2) === "./" || moduleName.substr(0, 3) === "../" || moduleName.substr(0, 2) === ".\\" || moduleName.substr(0, 3) === "..\\"; } function resolveExternalModuleName(location, moduleReferenceExpression) { - if (moduleReferenceExpression.kind !== 8 /* StringLiteral */) { + if (moduleReferenceExpression.kind !== 8) { return; } var moduleReferenceLiteral = moduleReferenceExpression; var searchPath = ts.getDirectoryPath(getSourceFile(location).fileName); - // Module names are escaped in our symbol table. However, string literal values aren't. - // Escape the name in the "require(...)" clause to ensure we find the right symbol. var moduleName = ts.escapeIdentifier(moduleReferenceLiteral.text); if (!moduleName) return; var isRelative = isExternalModuleNameRelative(moduleName); if (!isRelative) { - var symbol = getSymbol(globals, '"' + moduleName + '"', 512 /* ValueModule */); + var symbol = getSymbol(globals, '"' + moduleName + '"', 512); if (symbol) { return symbol; } @@ -11919,17 +9612,12 @@ var ts; } error(moduleReferenceLiteral, ts.Diagnostics.Cannot_find_module_0, moduleName); } - // An external module with an 'export =' declaration resolves to the target of the 'export =' declaration, - // and an external module with no 'export =' declaration resolves to the module itself. function resolveExternalModuleSymbol(moduleSymbol) { return moduleSymbol && resolveSymbol(moduleSymbol.exports["export="]) || moduleSymbol; } - // An external module with an 'export =' declaration may be referenced as an ES6 module provided the 'export =' - // references a symbol that is at least declared as a module or a variable. The target of the 'export =' may - // combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable). function resolveESModuleSymbol(moduleSymbol, moduleReferenceExpression) { var symbol = resolveExternalModuleSymbol(moduleSymbol); - if (symbol && !(symbol.flags & (1536 /* Module */ | 3 /* Variable */))) { + if (symbol && !(symbol.flags & (1536 | 3))) { error(moduleReferenceExpression, ts.Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol)); symbol = undefined; } @@ -11942,7 +9630,7 @@ var ts; return symbolsToArray(getExportsOfModule(moduleSymbol)); } function getExportsOfSymbol(symbol) { - return symbol.flags & 1536 /* Module */ ? getExportsOfModule(symbol) : symbol.exports || emptySymbols; + return symbol.flags & 1536 ? getExportsOfModule(symbol) : symbol.exports || emptySymbols; } function getExportsOfModule(moduleSymbol) { var links = getSymbolLinks(moduleSymbol); @@ -11960,10 +9648,8 @@ var ts; var visitedSymbols = []; visit(moduleSymbol); return result || moduleSymbol.exports; - // The ES6 spec permits export * declarations in a module to circularly reference the module itself. For example, - // module 'a' can 'export * from "b"' and 'b' can 'export * from "a"' without error. function visit(symbol) { - if (symbol && symbol.flags & 1952 /* HasExports */ && !ts.contains(visitedSymbols, symbol)) { + if (symbol && symbol.flags & 1952 && !ts.contains(visitedSymbols, symbol)) { visitedSymbols.push(symbol); if (symbol !== moduleSymbol) { if (!result) { @@ -11971,7 +9657,6 @@ var ts; } extendExportSymbols(result, symbol.exports); } - // All export * declarations are collected in an __export symbol by the binder var exportStars = symbol.exports["__export"]; if (exportStars) { for (var _i = 0, _a = exportStars.declarations; _i < _a.length; _i++) { @@ -11993,23 +9678,19 @@ var ts; return getMergedSymbol(symbol.parent); } function getExportSymbolOfValueSymbolIfExported(symbol) { - return symbol && (symbol.flags & 1048576 /* ExportValue */) !== 0 + return symbol && (symbol.flags & 1048576) !== 0 ? getMergedSymbol(symbol.exportSymbol) : symbol; } function symbolIsValue(symbol) { - // If it is an instantiated symbol, then it is a value if the symbol it is an - // instantiation of is a value. - if (symbol.flags & 16777216 /* Instantiated */) { + if (symbol.flags & 16777216) { return symbolIsValue(getSymbolLinks(symbol).target); } - // If the symbol has the value flag, it is trivially a value. - if (symbol.flags & 107455 /* Value */) { + if (symbol.flags & 107455) { return true; } - // If it is an alias, then it is a value if the symbol it resolves to is a value. - if (symbol.flags & 8388608 /* Alias */) { - return (resolveAlias(symbol).flags & 107455 /* Value */) !== 0; + if (symbol.flags & 8388608) { + return (resolveAlias(symbol).flags & 107455) !== 0; } return false; } @@ -12017,7 +9698,7 @@ var ts; var members = node.members; for (var _i = 0; _i < members.length; _i++) { var member = members[_i]; - if (member.kind === 136 /* Constructor */ && ts.nodeIsPresent(member.body)) { + if (member.kind === 136 && ts.nodeIsPresent(member.body)) { return member; } } @@ -12037,15 +9718,11 @@ var ts; type.symbol = symbol; return type; } - // A reserved member name starts with two underscores, but the third character cannot be an underscore - // or the @ symbol. A third underscore indicates an escaped form of an identifer that started - // with at least two underscores. The @ character indicates that the name is denoted by a well known ES - // Symbol instance. function isReservedMemberName(name) { - return name.charCodeAt(0) === 95 /* _ */ && - name.charCodeAt(1) === 95 /* _ */ && - name.charCodeAt(2) !== 95 /* _ */ && - name.charCodeAt(2) !== 64 /* at */; + return name.charCodeAt(0) === 95 && + name.charCodeAt(1) === 95 && + name.charCodeAt(2) !== 95 && + name.charCodeAt(2) !== 64; } function getNamedMembers(members) { var result; @@ -12075,29 +9752,28 @@ var ts; return type; } function createAnonymousType(symbol, members, callSignatures, constructSignatures, stringIndexType, numberIndexType) { - return setObjectTypeMembers(createObjectType(32768 /* Anonymous */, symbol), members, callSignatures, constructSignatures, stringIndexType, numberIndexType); + return setObjectTypeMembers(createObjectType(32768, symbol), members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } function forEachSymbolTableInScope(enclosingDeclaration, callback) { var result; for (var location_1 = enclosingDeclaration; location_1; location_1 = location_1.parent) { - // Locals of a source file are not in scope (because they get merged into the global symbol table) if (location_1.locals && !isGlobalSourceFile(location_1)) { if (result = callback(location_1.locals)) { return result; } } switch (location_1.kind) { - case 228 /* SourceFile */: + case 228: if (!ts.isExternalModule(location_1)) { break; } - case 206 /* ModuleDeclaration */: + case 206: if (result = callback(getSymbolOfNode(location_1).exports)) { return result; } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 202: + case 203: if (result = callback(getSymbolOfNode(location_1).members)) { return result; } @@ -12107,45 +9783,34 @@ var ts; return callback(globals); } function getQualifiedLeftMeaning(rightMeaning) { - // If we are looking in value space, the parent meaning is value, other wise it is namespace - return rightMeaning === 107455 /* Value */ ? 107455 /* Value */ : 1536 /* Namespace */; + return rightMeaning === 107455 ? 107455 : 1536; } function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing) { function getAccessibleSymbolChainFromSymbolTable(symbols) { function canQualifySymbol(symbolFromSymbolTable, meaning) { - // If the symbol is equivalent and doesn't need further qualification, this symbol is accessible if (!needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning)) { return true; } - // If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too var accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing); return !!accessibleParent; } function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol) { if (symbol === (resolvedAliasSymbol || symbolFromSymbolTable)) { - // if the symbolFromSymbolTable is not external module (it could be if it was determined as ambient external module and would be in globals table) - // and if symbolfrom symbolTable or alias resolution matches the symbol, - // check the symbol can be qualified, it is only then this symbol is accessible return !ts.forEach(symbolFromSymbolTable.declarations, hasExternalModuleSymbol) && canQualifySymbol(symbolFromSymbolTable, meaning); } } - // If symbol is directly available by its name in the symbol table if (isAccessible(ts.lookUp(symbols, symbol.name))) { return [symbol]; } - // Check if symbol is any of the alias return ts.forEachValue(symbols, function (symbolFromSymbolTable) { - if (symbolFromSymbolTable.flags & 8388608 /* Alias */ && symbolFromSymbolTable.name !== "export=") { + if (symbolFromSymbolTable.flags & 8388608 && symbolFromSymbolTable.name !== "export=") { if (!useOnlyExternalAliasing || - // Is this external alias, then use it to name ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) { var resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable); if (isAccessible(symbolFromSymbolTable, resolveAlias(symbolFromSymbolTable))) { return [symbolFromSymbolTable]; } - // Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain - // but only if the symbolFromSymbolTable can be qualified var accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined; if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) { return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports); @@ -12161,82 +9826,59 @@ var ts; function needsQualification(symbol, enclosingDeclaration, meaning) { var qualify = false; forEachSymbolTableInScope(enclosingDeclaration, function (symbolTable) { - // If symbol of this name is not available in the symbol table we are ok if (!ts.hasProperty(symbolTable, symbol.name)) { - // Continue to the next symbol table return false; } - // If the symbol with this name is present it should refer to the symbol var symbolFromSymbolTable = symbolTable[symbol.name]; if (symbolFromSymbolTable === symbol) { - // No need to qualify return true; } - // Qualify if the symbol from symbol table has same meaning as expected - symbolFromSymbolTable = (symbolFromSymbolTable.flags & 8388608 /* Alias */) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable; + symbolFromSymbolTable = (symbolFromSymbolTable.flags & 8388608) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable; if (symbolFromSymbolTable.flags & meaning) { qualify = true; return true; } - // Continue to the next symbol table return false; }); return qualify; } function isSymbolAccessible(symbol, enclosingDeclaration, meaning) { - if (symbol && enclosingDeclaration && !(symbol.flags & 262144 /* TypeParameter */)) { + if (symbol && enclosingDeclaration && !(symbol.flags & 262144)) { var initialSymbol = symbol; var meaningToLook = meaning; while (symbol) { - // Symbol is accessible if it by itself is accessible var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, false); if (accessibleSymbolChain) { var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]); if (!hasAccessibleDeclarations) { return { - accessibility: 1 /* NotAccessible */, + accessibility: 1, errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning), - errorModuleName: symbol !== initialSymbol ? symbolToString(symbol, enclosingDeclaration, 1536 /* Namespace */) : undefined + errorModuleName: symbol !== initialSymbol ? symbolToString(symbol, enclosingDeclaration, 1536) : undefined }; } return hasAccessibleDeclarations; } - // If we haven't got the accessible symbol, it doesn't mean the symbol is actually inaccessible. - // It could be a qualified symbol and hence verify the path - // e.g.: - // module m { - // export class c { - // } - // } - // let x: typeof m.c - // In the above example when we start with checking if typeof m.c symbol is accessible, - // we are going to see if c can be accessed in scope directly. - // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible - // It is accessible if the parent m is accessible because then m.c can be accessed through qualification meaningToLook = getQualifiedLeftMeaning(meaning); symbol = getParentOfSymbol(symbol); } - // This could be a symbol that is not exported in the external module - // or it could be a symbol from different external module that is not aliased and hence cannot be named var symbolExternalModule = ts.forEach(initialSymbol.declarations, getExternalModuleContainer); if (symbolExternalModule) { var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration); if (symbolExternalModule !== enclosingExternalModule) { - // name from different external module that is not visible return { - accessibility: 2 /* CannotBeNamed */, + accessibility: 2, errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning), errorModuleName: symbolToString(symbolExternalModule) }; } } - // Just a local name that is not accessible return { - accessibility: 1 /* NotAccessible */, + accessibility: 1, errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning) }; } - return { accessibility: 0 /* Accessible */ }; + return { accessibility: 0 }; function getExternalModuleContainer(declaration) { for (; declaration; declaration = declaration.parent) { if (hasExternalModuleSymbol(declaration)) { @@ -12246,22 +9888,20 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 206 /* ModuleDeclaration */ && declaration.name.kind === 8 /* StringLiteral */) || - (declaration.kind === 228 /* SourceFile */ && ts.isExternalModule(declaration)); + return (declaration.kind === 206 && declaration.name.kind === 8) || + (declaration.kind === 228 && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; if (ts.forEach(symbol.declarations, function (declaration) { return !getIsDeclarationVisible(declaration); })) { return undefined; } - return { accessibility: 0 /* Accessible */, aliasesToMakeVisible: aliasesToMakeVisible }; + return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible }; function getIsDeclarationVisible(declaration) { if (!isDeclarationVisible(declaration)) { - // Mark the unexported alias as visible if its parent is visible - // because these kind of aliases can be used to name types in declaration file var anyImportSyntax = getAnyImportSyntax(declaration); if (anyImportSyntax && - !(anyImportSyntax.flags & 1 /* Export */) && + !(anyImportSyntax.flags & 1) && isDeclarationVisible(anyImportSyntax.parent)) { getNodeLinks(declaration).isVisible = true; if (aliasesToMakeVisible) { @@ -12274,34 +9914,27 @@ var ts; } return true; } - // Declaration is not visible return false; } return true; } } function isEntityNameVisible(entityName, enclosingDeclaration) { - // get symbol of the first identifier of the entityName var meaning; - if (entityName.parent.kind === 145 /* TypeQuery */) { - // Typeof value - meaning = 107455 /* Value */ | 1048576 /* ExportValue */; + if (entityName.parent.kind === 145) { + meaning = 107455 | 1048576; } - else if (entityName.kind === 127 /* QualifiedName */ || entityName.kind === 156 /* PropertyAccessExpression */ || - entityName.parent.kind === 209 /* ImportEqualsDeclaration */) { - // Left identifier from type reference or TypeAlias - // Entity name of the import declaration - meaning = 1536 /* Namespace */; + else if (entityName.kind === 127 || entityName.kind === 156 || + entityName.parent.kind === 209) { + meaning = 1536; } else { - // Type Reference or TypeAlias entity = Identifier - meaning = 793056 /* Type */; + meaning = 793056; } var firstIdentifier = getFirstIdentifier(entityName); var symbol = resolveName(enclosingDeclaration, firstIdentifier.text, meaning, undefined, undefined); - // Verify if the symbol is accessible return (symbol && hasVisibleDeclarations(symbol)) || { - accessibility: 1 /* NotAccessible */, + accessibility: 1, errorSymbolName: ts.getTextOfNode(firstIdentifier), errorNode: firstIdentifier }; @@ -12327,31 +9960,26 @@ var ts; getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); var result = writer.string(); ts.releaseStringWriter(writer); - var maxLength = compilerOptions.noErrorTruncation || flags & 4 /* NoTruncation */ ? undefined : 100; + var maxLength = compilerOptions.noErrorTruncation || flags & 4 ? undefined : 100; if (maxLength && result.length >= maxLength) { result = result.substr(0, maxLength - "...".length) + "..."; } return result; } function getTypeAliasForTypeLiteral(type) { - if (type.symbol && type.symbol.flags & 2048 /* TypeLiteral */) { + if (type.symbol && type.symbol.flags & 2048) { var node = type.symbol.declarations[0].parent; - while (node.kind === 150 /* ParenthesizedType */) { + while (node.kind === 150) { node = node.parent; } - if (node.kind === 204 /* TypeAliasDeclaration */) { + if (node.kind === 204) { return getSymbolOfNode(node); } } return undefined; } - // This is for caching the result of getSymbolDisplayBuilder. Do not access directly. var _displayBuilder; function getSymbolDisplayBuilder() { - /** - * Writes only the name of the symbol out to the writer. Uses the original source text - * for the name of the symbol if it is available to match how the user inputted the name. - */ function appendSymbolNameOnly(symbol, writer) { if (symbol.declarations && symbol.declarations.length > 0) { var declaration = symbol.declarations[0]; @@ -12362,42 +9990,29 @@ var ts; } writer.writeSymbol(symbol.name, symbol); } - /** - * Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope - * Meaning needs to be specified if the enclosing declaration is given - */ function buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags, typeFlags) { var parentSymbol; function appendParentTypeArgumentsAndSymbolName(symbol) { if (parentSymbol) { - // Write type arguments of instantiated class/interface here - if (flags & 1 /* WriteTypeParametersOrArguments */) { - if (symbol.flags & 16777216 /* Instantiated */) { + if (flags & 1) { + if (symbol.flags & 16777216) { buildDisplayForTypeArgumentsAndDelimiters(getTypeParametersOfClassOrInterface(parentSymbol), symbol.mapper, writer, enclosingDeclaration); } else { buildTypeParameterDisplayFromSymbol(parentSymbol, writer, enclosingDeclaration); } } - writePunctuation(writer, 20 /* DotToken */); + writePunctuation(writer, 20); } parentSymbol = symbol; appendSymbolNameOnly(symbol, writer); } - // Let the writer know we just wrote out a symbol. The declaration emitter writer uses - // this to determine if an import it has previously seen (and not written out) needs - // to be written to the file once the walk of the tree is complete. - // - // NOTE(cyrusn): This approach feels somewhat unfortunate. A simple pass over the tree - // up front (for example, during checking) could determine if we need to emit the imports - // and we could then access that data during declaration emit. writer.trackSymbol(symbol, enclosingDeclaration, meaning); function walkSymbol(symbol, meaning) { if (symbol) { - var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & 2 /* UseOnlyExternalAliasing */)); + var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & 2)); if (!accessibleSymbolChain || needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) { - // Go up and add our parent. walkSymbol(getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol), getQualifiedLeftMeaning(meaning)); } if (accessibleSymbolChain) { @@ -12407,23 +10022,18 @@ var ts; } } else { - // If we didn't find accessible symbol chain for this symbol, break if this is external module if (!parentSymbol && ts.forEach(symbol.declarations, hasExternalModuleSymbol)) { return; } - // if this is anonymous type break - if (symbol.flags & 2048 /* TypeLiteral */ || symbol.flags & 4096 /* ObjectLiteral */) { + if (symbol.flags & 2048 || symbol.flags & 4096) { return; } appendParentTypeArgumentsAndSymbolName(symbol); } } } - // Get qualified name if the symbol is not a type parameter - // and there is an enclosing declaration or we specifically - // asked for it - var isTypeParameter = symbol.flags & 262144 /* TypeParameter */; - var typeFormatFlag = 128 /* UseFullyQualifiedType */ & typeFlags; + var isTypeParameter = symbol.flags & 262144; + var typeFormatFlag = 128 & typeFlags; if (!isTypeParameter && (enclosingDeclaration || typeFormatFlag)) { walkSymbol(symbol, meaning); return; @@ -12431,42 +10041,37 @@ var ts; return appendParentTypeArgumentsAndSymbolName(symbol); } function buildTypeDisplay(type, writer, enclosingDeclaration, globalFlags, typeStack) { - var globalFlagsToPass = globalFlags & 16 /* WriteOwnNameForAnyLike */; + var globalFlagsToPass = globalFlags & 16; return writeType(type, globalFlags); function writeType(type, flags) { - // Write undefined/null type as any - if (type.flags & 1048703 /* Intrinsic */) { - // Special handling for unknown / resolving types, they should show up as any and not unknown or __resolving - writer.writeKeyword(!(globalFlags & 16 /* WriteOwnNameForAnyLike */) && - (type.flags & 1 /* Any */) ? "any" : type.intrinsicName); + if (type.flags & 1048703) { + writer.writeKeyword(!(globalFlags & 16) && + (type.flags & 1) ? "any" : type.intrinsicName); } - else if (type.flags & 4096 /* Reference */) { + else if (type.flags & 4096) { writeTypeReference(type, flags); } - else if (type.flags & (1024 /* Class */ | 2048 /* Interface */ | 128 /* Enum */ | 512 /* TypeParameter */)) { - // The specified symbol flags need to be reinterpreted as type flags - buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 793056 /* Type */, 0 /* None */, flags); + else if (type.flags & (1024 | 2048 | 128 | 512)) { + buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 793056, 0, flags); } - else if (type.flags & 8192 /* Tuple */) { + else if (type.flags & 8192) { writeTupleType(type); } - else if (type.flags & 16384 /* Union */) { + else if (type.flags & 16384) { writeUnionType(type, flags); } - else if (type.flags & 32768 /* Anonymous */) { + else if (type.flags & 32768) { writeAnonymousType(type, flags); } - else if (type.flags & 256 /* StringLiteral */) { + else if (type.flags & 256) { writer.writeStringLiteral(type.text); } else { - // Should never get here - // { ... } - writePunctuation(writer, 14 /* OpenBraceToken */); + writePunctuation(writer, 14); writeSpace(writer); - writePunctuation(writer, 21 /* DotDotDotToken */); + writePunctuation(writer, 21); writeSpace(writer); - writePunctuation(writer, 15 /* CloseBraceToken */); + writePunctuation(writer, 15); } } function writeTypeList(types, union) { @@ -12475,57 +10080,53 @@ var ts; if (union) { writeSpace(writer); } - writePunctuation(writer, union ? 44 /* BarToken */ : 23 /* CommaToken */); + writePunctuation(writer, union ? 44 : 23); writeSpace(writer); } - writeType(types[i], union ? 64 /* InElementType */ : 0 /* None */); + writeType(types[i], union ? 64 : 0); } } function writeTypeReference(type, flags) { - if (type.target === globalArrayType && !(flags & 1 /* WriteArrayAsGenericType */)) { - writeType(type.typeArguments[0], 64 /* InElementType */); - writePunctuation(writer, 18 /* OpenBracketToken */); - writePunctuation(writer, 19 /* CloseBracketToken */); + if (type.target === globalArrayType && !(flags & 1)) { + writeType(type.typeArguments[0], 64); + writePunctuation(writer, 18); + writePunctuation(writer, 19); } else { - buildSymbolDisplay(type.target.symbol, writer, enclosingDeclaration, 793056 /* Type */); - writePunctuation(writer, 24 /* LessThanToken */); + buildSymbolDisplay(type.target.symbol, writer, enclosingDeclaration, 793056); + writePunctuation(writer, 24); writeTypeList(type.typeArguments, false); - writePunctuation(writer, 25 /* GreaterThanToken */); + writePunctuation(writer, 25); } } function writeTupleType(type) { - writePunctuation(writer, 18 /* OpenBracketToken */); + writePunctuation(writer, 18); writeTypeList(type.elementTypes, false); - writePunctuation(writer, 19 /* CloseBracketToken */); + writePunctuation(writer, 19); } function writeUnionType(type, flags) { - if (flags & 64 /* InElementType */) { - writePunctuation(writer, 16 /* OpenParenToken */); + if (flags & 64) { + writePunctuation(writer, 16); } writeTypeList(type.types, true); - if (flags & 64 /* InElementType */) { - writePunctuation(writer, 17 /* CloseParenToken */); + if (flags & 64) { + writePunctuation(writer, 17); } } function writeAnonymousType(type, flags) { - // Always use 'typeof T' for type of class, enum, and module objects - if (type.symbol && type.symbol.flags & (32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) { + if (type.symbol && type.symbol.flags & (32 | 384 | 512)) { writeTypeofSymbol(type, flags); } else if (shouldWriteTypeOfFunctionSymbol()) { writeTypeofSymbol(type, flags); } else if (typeStack && ts.contains(typeStack, type)) { - // If type is an anonymous type literal in a type alias declaration, use type alias name var typeAlias = getTypeAliasForTypeLiteral(type); if (typeAlias) { - // The specified symbol flags need to be reinterpreted as type flags - buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, 793056 /* Type */, 0 /* None */, flags); + buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, 793056, 0, flags); } else { - // Recursive usage, use any - writeKeyword(writer, 112 /* AnyKeyword */); + writeKeyword(writer, 112); } } else { @@ -12538,31 +10139,28 @@ var ts; } function shouldWriteTypeOfFunctionSymbol() { if (type.symbol) { - var isStaticMethodSymbol = !!(type.symbol.flags & 8192 /* Method */ && - ts.forEach(type.symbol.declarations, function (declaration) { return declaration.flags & 128 /* Static */; })); - var isNonLocalFunctionSymbol = !!(type.symbol.flags & 16 /* Function */) && + var isStaticMethodSymbol = !!(type.symbol.flags & 8192 && + ts.forEach(type.symbol.declarations, function (declaration) { return declaration.flags & 128; })); + var isNonLocalFunctionSymbol = !!(type.symbol.flags & 16) && (type.symbol.parent || ts.forEach(type.symbol.declarations, function (declaration) { - return declaration.parent.kind === 228 /* SourceFile */ || declaration.parent.kind === 207 /* ModuleBlock */; + return declaration.parent.kind === 228 || declaration.parent.kind === 207; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { - // typeof is allowed only for static/non local functions - return !!(flags & 2 /* UseTypeOfFunction */) || - (typeStack && ts.contains(typeStack, type)); // it is type of the symbol uses itself recursively + return !!(flags & 2) || + (typeStack && ts.contains(typeStack, type)); } } } } function writeTypeofSymbol(type, typeFormatFlags) { - writeKeyword(writer, 97 /* TypeOfKeyword */); + writeKeyword(writer, 97); writeSpace(writer); - buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 107455 /* Value */, 0 /* None */, typeFormatFlags); + buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 107455, 0, typeFormatFlags); } function getIndexerParameterName(type, indexKind, fallbackName) { var declaration = getIndexDeclarationOfSymbol(type.symbol, indexKind); if (!declaration) { - // declaration might not be found if indexer was added from the contextual type. - // in this case use fallback name return fallbackName; } ts.Debug.assert(declaration.parameters.length !== 0); @@ -12572,113 +10170,111 @@ var ts; var resolved = resolveObjectOrUnionTypeMembers(type); if (!resolved.properties.length && !resolved.stringIndexType && !resolved.numberIndexType) { if (!resolved.callSignatures.length && !resolved.constructSignatures.length) { - writePunctuation(writer, 14 /* OpenBraceToken */); - writePunctuation(writer, 15 /* CloseBraceToken */); + writePunctuation(writer, 14); + writePunctuation(writer, 15); return; } if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) { - if (flags & 64 /* InElementType */) { - writePunctuation(writer, 16 /* OpenParenToken */); + if (flags & 64) { + writePunctuation(writer, 16); } - buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8 /* WriteArrowStyleSignature */, typeStack); - if (flags & 64 /* InElementType */) { - writePunctuation(writer, 17 /* CloseParenToken */); + buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8, typeStack); + if (flags & 64) { + writePunctuation(writer, 17); } return; } if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) { - if (flags & 64 /* InElementType */) { - writePunctuation(writer, 16 /* OpenParenToken */); + if (flags & 64) { + writePunctuation(writer, 16); } - writeKeyword(writer, 88 /* NewKeyword */); + writeKeyword(writer, 88); writeSpace(writer); - buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8 /* WriteArrowStyleSignature */, typeStack); - if (flags & 64 /* InElementType */) { - writePunctuation(writer, 17 /* CloseParenToken */); + buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8, typeStack); + if (flags & 64) { + writePunctuation(writer, 17); } return; } } - writePunctuation(writer, 14 /* OpenBraceToken */); + writePunctuation(writer, 14); writer.writeLine(); writer.increaseIndent(); for (var _i = 0, _a = resolved.callSignatures; _i < _a.length; _i++) { var signature = _a[_i]; buildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, typeStack); - writePunctuation(writer, 22 /* SemicolonToken */); + writePunctuation(writer, 22); writer.writeLine(); } for (var _b = 0, _c = resolved.constructSignatures; _b < _c.length; _b++) { var signature = _c[_b]; - writeKeyword(writer, 88 /* NewKeyword */); + writeKeyword(writer, 88); writeSpace(writer); buildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, typeStack); - writePunctuation(writer, 22 /* SemicolonToken */); + writePunctuation(writer, 22); writer.writeLine(); } if (resolved.stringIndexType) { - // [x: string]: - writePunctuation(writer, 18 /* OpenBracketToken */); - writer.writeParameter(getIndexerParameterName(resolved, 0 /* String */, "x")); - writePunctuation(writer, 51 /* ColonToken */); + writePunctuation(writer, 18); + writer.writeParameter(getIndexerParameterName(resolved, 0, "x")); + writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 122 /* StringKeyword */); - writePunctuation(writer, 19 /* CloseBracketToken */); - writePunctuation(writer, 51 /* ColonToken */); + writeKeyword(writer, 122); + writePunctuation(writer, 19); + writePunctuation(writer, 51); writeSpace(writer); - writeType(resolved.stringIndexType, 0 /* None */); - writePunctuation(writer, 22 /* SemicolonToken */); + writeType(resolved.stringIndexType, 0); + writePunctuation(writer, 22); writer.writeLine(); } if (resolved.numberIndexType) { - // [x: number]: - writePunctuation(writer, 18 /* OpenBracketToken */); - writer.writeParameter(getIndexerParameterName(resolved, 1 /* Number */, "x")); - writePunctuation(writer, 51 /* ColonToken */); + writePunctuation(writer, 18); + writer.writeParameter(getIndexerParameterName(resolved, 1, "x")); + writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 120 /* NumberKeyword */); - writePunctuation(writer, 19 /* CloseBracketToken */); - writePunctuation(writer, 51 /* ColonToken */); + writeKeyword(writer, 120); + writePunctuation(writer, 19); + writePunctuation(writer, 51); writeSpace(writer); - writeType(resolved.numberIndexType, 0 /* None */); - writePunctuation(writer, 22 /* SemicolonToken */); + writeType(resolved.numberIndexType, 0); + writePunctuation(writer, 22); writer.writeLine(); } for (var _d = 0, _e = resolved.properties; _d < _e.length; _d++) { var p = _e[_d]; var t = getTypeOfSymbol(p); - if (p.flags & (16 /* Function */ | 8192 /* Method */) && !getPropertiesOfObjectType(t).length) { - var signatures = getSignaturesOfType(t, 0 /* Call */); + if (p.flags & (16 | 8192) && !getPropertiesOfObjectType(t).length) { + var signatures = getSignaturesOfType(t, 0); for (var _f = 0; _f < signatures.length; _f++) { var signature = signatures[_f]; buildSymbolDisplay(p, writer); - if (p.flags & 536870912 /* Optional */) { - writePunctuation(writer, 50 /* QuestionToken */); + if (p.flags & 536870912) { + writePunctuation(writer, 50); } buildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, typeStack); - writePunctuation(writer, 22 /* SemicolonToken */); + writePunctuation(writer, 22); writer.writeLine(); } } else { buildSymbolDisplay(p, writer); - if (p.flags & 536870912 /* Optional */) { - writePunctuation(writer, 50 /* QuestionToken */); + if (p.flags & 536870912) { + writePunctuation(writer, 50); } - writePunctuation(writer, 51 /* ColonToken */); + writePunctuation(writer, 51); writeSpace(writer); - writeType(t, 0 /* None */); - writePunctuation(writer, 22 /* SemicolonToken */); + writeType(t, 0); + writePunctuation(writer, 22); writer.writeLine(); } } writer.decreaseIndent(); - writePunctuation(writer, 15 /* CloseBraceToken */); + writePunctuation(writer, 15); } } function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaraiton, flags) { var targetSymbol = getTargetSymbol(symbol); - if (targetSymbol.flags & 32 /* Class */ || targetSymbol.flags & 64 /* Interface */) { + if (targetSymbol.flags & 32 || targetSymbol.flags & 64) { buildDisplayForTypeParametersAndDelimiters(getTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags); } } @@ -12687,75 +10283,73 @@ var ts; var constraint = getConstraintOfTypeParameter(tp); if (constraint) { writeSpace(writer); - writeKeyword(writer, 79 /* ExtendsKeyword */); + writeKeyword(writer, 79); writeSpace(writer); buildTypeDisplay(constraint, writer, enclosingDeclaration, flags, typeStack); } } function buildParameterDisplay(p, writer, enclosingDeclaration, flags, typeStack) { if (ts.hasDotDotDotToken(p.valueDeclaration)) { - writePunctuation(writer, 21 /* DotDotDotToken */); + writePunctuation(writer, 21); } appendSymbolNameOnly(p, writer); if (ts.hasQuestionToken(p.valueDeclaration) || p.valueDeclaration.initializer) { - writePunctuation(writer, 50 /* QuestionToken */); + writePunctuation(writer, 50); } - writePunctuation(writer, 51 /* ColonToken */); + writePunctuation(writer, 51); writeSpace(writer); buildTypeDisplay(getTypeOfSymbol(p), writer, enclosingDeclaration, flags, typeStack); } function buildDisplayForTypeParametersAndDelimiters(typeParameters, writer, enclosingDeclaration, flags, typeStack) { if (typeParameters && typeParameters.length) { - writePunctuation(writer, 24 /* LessThanToken */); + writePunctuation(writer, 24); for (var i = 0; i < typeParameters.length; i++) { if (i > 0) { - writePunctuation(writer, 23 /* CommaToken */); + writePunctuation(writer, 23); writeSpace(writer); } buildTypeParameterDisplay(typeParameters[i], writer, enclosingDeclaration, flags, typeStack); } - writePunctuation(writer, 25 /* GreaterThanToken */); + writePunctuation(writer, 25); } } function buildDisplayForTypeArgumentsAndDelimiters(typeParameters, mapper, writer, enclosingDeclaration, flags, typeStack) { if (typeParameters && typeParameters.length) { - writePunctuation(writer, 24 /* LessThanToken */); + writePunctuation(writer, 24); for (var i = 0; i < typeParameters.length; i++) { if (i > 0) { - writePunctuation(writer, 23 /* CommaToken */); + writePunctuation(writer, 23); writeSpace(writer); } - buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, 0 /* None */); + buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, 0); } - writePunctuation(writer, 25 /* GreaterThanToken */); + writePunctuation(writer, 25); } } function buildDisplayForParametersAndDelimiters(parameters, writer, enclosingDeclaration, flags, typeStack) { - writePunctuation(writer, 16 /* OpenParenToken */); + writePunctuation(writer, 16); for (var i = 0; i < parameters.length; i++) { if (i > 0) { - writePunctuation(writer, 23 /* CommaToken */); + writePunctuation(writer, 23); writeSpace(writer); } buildParameterDisplay(parameters[i], writer, enclosingDeclaration, flags, typeStack); } - writePunctuation(writer, 17 /* CloseParenToken */); + writePunctuation(writer, 17); } function buildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, typeStack) { - if (flags & 8 /* WriteArrowStyleSignature */) { + if (flags & 8) { writeSpace(writer); - writePunctuation(writer, 32 /* EqualsGreaterThanToken */); + writePunctuation(writer, 32); } else { - writePunctuation(writer, 51 /* ColonToken */); + writePunctuation(writer, 51); } writeSpace(writer); buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags, typeStack); } function buildSignatureDisplay(signature, writer, enclosingDeclaration, flags, typeStack) { - if (signature.target && (flags & 32 /* WriteTypeArgumentsOfSignature */)) { - // Instantiated signature, write type arguments instead - // This is achieved by passing in the mapper separately + if (signature.target && (flags & 32)) { buildDisplayForTypeArgumentsAndDelimiters(signature.target.typeParameters, signature.mapper, writer, enclosingDeclaration); } else { @@ -12782,47 +10376,41 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 206 /* ModuleDeclaration */) { - if (node.name.kind === 8 /* StringLiteral */) { + if (node.kind === 206) { + if (node.name.kind === 8) { return node; } } - else if (node.kind === 228 /* SourceFile */) { + else if (node.kind === 228) { return ts.isExternalModule(node) ? node : undefined; } } ts.Debug.fail("getContainingModule cant reach here"); } function isUsedInExportAssignment(node) { - // Get source File and see if it is external module and has export assigned symbol var externalModule = getContainingExternalModule(node); var exportAssignmentSymbol; var resolvedExportSymbol; if (externalModule) { - // This is export assigned symbol node var externalModuleSymbol = getSymbolOfNode(externalModule); exportAssignmentSymbol = getExportAssignmentSymbol(externalModuleSymbol); var symbolOfNode = getSymbolOfNode(node); if (isSymbolUsedInExportAssignment(symbolOfNode)) { return true; } - // if symbolOfNode is alias declaration, resolve the symbol declaration and check - if (symbolOfNode.flags & 8388608 /* Alias */) { + if (symbolOfNode.flags & 8388608) { return isSymbolUsedInExportAssignment(resolveAlias(symbolOfNode)); } } - // Check if the symbol is used in export assignment function isSymbolUsedInExportAssignment(symbol) { if (exportAssignmentSymbol === symbol) { return true; } - if (exportAssignmentSymbol && !!(exportAssignmentSymbol.flags & 8388608 /* Alias */)) { - // if export assigned symbol is alias declaration, resolve the alias + if (exportAssignmentSymbol && !!(exportAssignmentSymbol.flags & 8388608)) { resolvedExportSymbol = resolvedExportSymbol || resolveAlias(exportAssignmentSymbol); if (resolvedExportSymbol === symbol) { return true; } - // Container of resolvedExportSymbol is visible return ts.forEach(resolvedExportSymbol.declarations, function (current) { while (current) { if (current === node) { @@ -12836,69 +10424,58 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 153 /* BindingElement */: + case 153: return isDeclarationVisible(node.parent.parent); - case 199 /* VariableDeclaration */: + case 199: if (ts.isBindingPattern(node.name) && !node.name.elements.length) { - // If the binding pattern is empty, this variable declaration is not visible return false; } - // Otherwise fall through - case 206 /* ModuleDeclaration */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 201 /* FunctionDeclaration */: - case 205 /* EnumDeclaration */: - case 209 /* ImportEqualsDeclaration */: + case 206: + case 202: + case 203: + case 204: + case 201: + case 205: + case 209: var parent_2 = getDeclarationContainer(node); - // If the node is not exported or it is not ambient module element (except import declaration) - if (!(ts.getCombinedNodeFlags(node) & 1 /* Export */) && - !(node.kind !== 209 /* ImportEqualsDeclaration */ && parent_2.kind !== 228 /* SourceFile */ && ts.isInAmbientContext(parent_2))) { + if (!(ts.getCombinedNodeFlags(node) & 1) && + !(node.kind !== 209 && parent_2.kind !== 228 && ts.isInAmbientContext(parent_2))) { return isGlobalSourceFile(parent_2); } - // Exported members/ambient module elements (exception import declaration) are visible if parent is visible return isDeclarationVisible(parent_2); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - if (node.flags & (32 /* Private */ | 64 /* Protected */)) { - // Private/protected properties/methods are not visible + case 133: + case 132: + case 137: + case 138: + case 135: + case 134: + if (node.flags & (32 | 64)) { return false; } - // Public properties/methods are visible if its parents are visible, so let it fall into next case statement - case 136 /* Constructor */: - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 141 /* IndexSignature */: - case 130 /* Parameter */: - case 207 /* ModuleBlock */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 146 /* TypeLiteral */: - case 142 /* TypeReference */: - case 147 /* ArrayType */: - case 148 /* TupleType */: - case 149 /* UnionType */: - case 150 /* ParenthesizedType */: + case 136: + case 140: + case 139: + case 141: + case 130: + case 207: + case 143: + case 144: + case 146: + case 142: + case 147: + case 148: + case 149: + case 150: return isDeclarationVisible(node.parent); - // Default binding, import specifier and namespace import is visible - // only on demand so by default it is not visible - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: + case 211: + case 212: + case 214: return false; - // Type parameters are always visible - case 129 /* TypeParameter */: - // Source file is always visible - case 228 /* SourceFile */: + case 129: + case 228: return true; - // Export assignements do not create name bindings outside the module - case 215 /* ExportAssignment */: + case 215: return false; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -12914,10 +10491,10 @@ var ts; } function collectLinkedAliases(node) { var exportSymbol; - if (node.parent && node.parent.kind === 215 /* ExportAssignment */) { - exportSymbol = resolveName(node.parent, node.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */, ts.Diagnostics.Cannot_find_name_0, node); + if (node.parent && node.parent.kind === 215) { + exportSymbol = resolveName(node.parent, node.text, 107455 | 793056 | 1536, ts.Diagnostics.Cannot_find_name_0, node); } - else if (node.parent.kind === 218 /* ExportSpecifier */) { + else if (node.parent.kind === 218) { exportSymbol = getTargetOfExportSpecifier(node.parent); } var result = []; @@ -12933,51 +10510,38 @@ var ts; result.push(resultNode); } if (ts.isInternalModuleImportEqualsDeclaration(declaration)) { - // Add the referenced top container visible var internalModuleReference = declaration.moduleReference; var firstIdentifier = getFirstIdentifier(internalModuleReference); - var importSymbol = resolveName(declaration, firstIdentifier.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */, ts.Diagnostics.Cannot_find_name_0, firstIdentifier); + var importSymbol = resolveName(declaration, firstIdentifier.text, 107455 | 793056 | 1536, ts.Diagnostics.Cannot_find_name_0, firstIdentifier); buildVisibleNodeList(importSymbol.declarations); } }); } } function getRootDeclaration(node) { - while (node.kind === 153 /* BindingElement */) { + while (node.kind === 153) { node = node.parent.parent; } return node; } function getDeclarationContainer(node) { node = getRootDeclaration(node); - // Parent chain: - // VaribleDeclaration -> VariableDeclarationList -> VariableStatement -> 'Declaration Container' - return node.kind === 199 /* VariableDeclaration */ ? node.parent.parent.parent : node.parent; + return node.kind === 199 ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { - // TypeScript 1.0 spec (April 2014): 8.4 - // Every class automatically contains a static property member named 'prototype', - // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter. - // It is an error to explicitly declare a static property member with the name 'prototype'. var classType = getDeclaredTypeOfSymbol(prototype.parent); return classType.typeParameters ? createTypeReference(classType, ts.map(classType.typeParameters, function (_) { return anyType; })) : classType; } - // Return the type of the given property in the given type, or undefined if no such property exists function getTypeOfPropertyOfType(type, name) { var prop = getPropertyOfType(type, name); return prop ? getTypeOfSymbol(prop) : undefined; } - // Return the inferred type for a binding element function getTypeForBindingElement(declaration) { var pattern = declaration.parent; var parentType = getTypeForVariableLikeDeclaration(pattern.parent); - // If parent has the unknown (error) type, then so does this binding element if (parentType === unknownType) { return unknownType; } - // If no type was specified or inferred for parent, or if the specified or inferred type is any, - // infer from the initializer of the binding element if one is present. Otherwise, go with the - // undefined or any type of the parent. if (!parentType || parentType === anyType) { if (declaration.initializer) { return checkExpressionCached(declaration.initializer); @@ -12985,29 +10549,22 @@ var ts; return parentType; } var type; - if (pattern.kind === 151 /* ObjectBindingPattern */) { - // Use explicitly specified property name ({ p: xxx } form), or otherwise the implied name ({ p } form) + if (pattern.kind === 151) { var name_5 = declaration.propertyName || declaration.name; - // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature, - // or otherwise the type of the string index signature. type = getTypeOfPropertyOfType(parentType, name_5.text) || - isNumericLiteralName(name_5.text) && getIndexTypeOfType(parentType, 1 /* Number */) || - getIndexTypeOfType(parentType, 0 /* String */); + isNumericLiteralName(name_5.text) && getIndexTypeOfType(parentType, 1) || + getIndexTypeOfType(parentType, 0); if (!type) { error(name_5, ts.Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), ts.declarationNameToString(name_5)); return unknownType; } } else { - // This elementType will be used if the specific property corresponding to this index is not - // present (aka the tuple element property). This call also checks that the parentType is in - // fact an iterable or array (depending on target language). var elementType = checkIteratedTypeOrElementType(parentType, pattern, false); if (!declaration.dotDotDotToken) { - if (elementType.flags & 1 /* Any */) { + if (elementType.flags & 1) { return elementType; } - // Use specific property type when parent is a tuple or numeric index type when parent is an array var propName = "" + ts.indexOf(pattern.elements, declaration); type = isTupleLikeType(parentType) ? getTypeOfPropertyOfType(parentType, propName) @@ -13023,61 +10580,45 @@ var ts; } } else { - // Rest element has an array type with the same element type as the parent type type = createArrayType(elementType); } } return type; } - // Return the inferred type for a variable, parameter, or property declaration function getTypeForVariableLikeDeclaration(declaration) { - // A variable declared in a for..in statement is always of type any - if (declaration.parent.parent.kind === 188 /* ForInStatement */) { + if (declaration.parent.parent.kind === 188) { return anyType; } - if (declaration.parent.parent.kind === 189 /* ForOfStatement */) { - // checkRightHandSideOfForOf will return undefined if the for-of expression type was - // missing properties/signatures required to get its iteratedType (like - // [Symbol.iterator] or next). This may be because we accessed properties from anyType, - // or it may have led to an error inside getIteratedType. + if (declaration.parent.parent.kind === 189) { return checkRightHandSideOfForOf(declaration.parent.parent.expression) || anyType; } if (ts.isBindingPattern(declaration.parent)) { return getTypeForBindingElement(declaration); } - // Use type from type annotation if one is present if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130 /* Parameter */) { + if (declaration.kind === 130) { var func = declaration.parent; - // For a parameter of a set accessor, use the type of the get accessor if one is present - if (func.kind === 138 /* SetAccessor */ && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 137 /* GetAccessor */); + if (func.kind === 138 && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 137); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } } - // Use contextual parameter type if one is available var type = getContextuallyTypedParameterType(declaration); if (type) { return type; } } - // Use the type of the initializer expression if one is present if (declaration.initializer) { return checkExpressionCached(declaration.initializer); } - // If it is a short-hand property assignment, use the type of the identifier - if (declaration.kind === 226 /* ShorthandPropertyAssignment */) { + if (declaration.kind === 226) { return checkIdentifier(declaration.name); } - // No type specified and nothing can be inferred return undefined; } - // Return the type implied by a binding pattern element. This is the type of the initializer of the element if - // one is present. Otherwise, if the element is itself a binding pattern, it is the type implied by the binding - // pattern. Otherwise, it is the type any. function getTypeFromBindingElement(element) { if (element.initializer) { return getWidenedType(checkExpressionCached(element.initializer)); @@ -13087,11 +10628,10 @@ var ts; } return anyType; } - // Return the type implied by an object binding pattern function getTypeFromObjectBindingPattern(pattern) { var members = {}; ts.forEach(pattern.elements, function (e) { - var flags = 4 /* Property */ | 67108864 /* Transient */ | (e.initializer ? 536870912 /* Optional */ : 0); + var flags = 4 | 67108864 | (e.initializer ? 536870912 : 0); var name = e.propertyName || e.name; var symbol = createSymbol(flags, name.text); symbol.type = getTypeFromBindingElement(e); @@ -13099,69 +10639,44 @@ var ts; }); return createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined); } - // Return the type implied by an array binding pattern function getTypeFromArrayBindingPattern(pattern) { var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 176 /* OmittedExpression */ || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 176 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } }); if (!elementTypes.length) { - return languageVersion >= 2 /* ES6 */ ? createIterableType(anyType) : anyArrayType; + return languageVersion >= 2 ? createIterableType(anyType) : anyArrayType; } else if (hasSpreadElement) { var unionOfElements = getUnionType(elementTypes); - return languageVersion >= 2 /* ES6 */ ? createIterableType(unionOfElements) : createArrayType(unionOfElements); + return languageVersion >= 2 ? createIterableType(unionOfElements) : createArrayType(unionOfElements); } - // If the pattern has at least one element, and no rest element, then it should imply a tuple type. return createTupleType(elementTypes); } - // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself - // and without regard to its context (i.e. without regard any type annotation or initializer associated with the - // declaration in which the binding pattern is contained). For example, the implied type of [x, y] is [any, any] - // and the implied type of { x, y: z = 1 } is { x: any; y: number; }. The type implied by a binding pattern is - // used as the contextual type of an initializer associated with the binding pattern. Also, for a destructuring - // parameter with no type annotation or initializer, the type implied by the binding pattern becomes the type of - // the parameter. function getTypeFromBindingPattern(pattern) { - return pattern.kind === 151 /* ObjectBindingPattern */ + return pattern.kind === 151 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } - // Return the type associated with a variable, parameter, or property declaration. In the simple case this is the type - // specified in a type annotation or inferred from an initializer. However, in the case of a destructuring declaration it - // is a bit more involved. For example: - // - // var [x, s = ""] = [1, "one"]; - // - // Here, the array literal [1, "one"] is contextually typed by the type [any, string], which is the implied type of the - // binding pattern [x, s = ""]. Because the contextual type is a tuple type, the resulting type of [1, "one"] is the - // tuple type [number, string]. Thus, the type inferred for 'x' is number and the type inferred for 's' is string. function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) { var type = getTypeForVariableLikeDeclaration(declaration); if (type) { if (reportErrors) { reportErrorsFromWidening(declaration, type); } - // During a normal type check we'll never get to here with a property assignment (the check of the containing - // object literal uses a different path). We exclude widening only so that language services and type verification - // tools see the actual type. - return declaration.kind !== 225 /* PropertyAssignment */ ? getWidenedType(type) : type; + return declaration.kind !== 225 ? getWidenedType(type) : type; } - // If no type was specified and nothing could be inferred, and if the declaration specifies a binding pattern, use - // the type implied by the binding pattern if (ts.isBindingPattern(declaration.name)) { return getTypeFromBindingPattern(declaration.name); } - // Rest parameters default to type any[], other parameters default to type any type = declaration.dotDotDotToken ? anyArrayType : anyType; - // Report implicit any errors unless this is a private property within an ambient declaration if (reportErrors && compilerOptions.noImplicitAny) { var root = getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 130 /* Parameter */ && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 130 && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -13170,20 +10685,16 @@ var ts; function getTypeOfVariableOrParameterOrProperty(symbol) { var links = getSymbolLinks(symbol); if (!links.type) { - // Handle prototype property - if (symbol.flags & 134217728 /* Prototype */) { + if (symbol.flags & 134217728) { return links.type = getTypeOfPrototypeProperty(symbol); } - // Handle catch clause variables var declaration = symbol.valueDeclaration; - if (declaration.parent.kind === 224 /* CatchClause */) { + if (declaration.parent.kind === 224) { return links.type = anyType; } - // Handle export default expressions - if (declaration.kind === 215 /* ExportAssignment */) { + if (declaration.kind === 215) { return links.type = checkExpression(declaration.expression); } - // Handle variable, parameter or property links.type = resolvingType; var type = getWidenedTypeForVariableLikeDeclaration(declaration, true); if (links.type === resolvingType) { @@ -13206,7 +10717,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 137 /* GetAccessor */) { + if (accessor.kind === 137) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -13225,22 +10736,19 @@ var ts; links = links || getSymbolLinks(symbol); if (!links.type) { links.type = resolvingType; - var getter = ts.getDeclarationOfKind(symbol, 137 /* GetAccessor */); - var setter = ts.getDeclarationOfKind(symbol, 138 /* SetAccessor */); + var getter = ts.getDeclarationOfKind(symbol, 137); + var setter = ts.getDeclarationOfKind(symbol, 138); var type; - // First try to see if the user specified a return type on the get-accessor. var getterReturnType = getAnnotatedAccessorType(getter); if (getterReturnType) { type = getterReturnType; } else { - // If the user didn't specify a return type, try to use the set-accessor's parameter type. var setterParameterType = getAnnotatedAccessorType(setter); if (setterParameterType) { type = setterParameterType; } else { - // If there are no specified types, try to infer it from the body of the get accessor if it exists. if (getter && getter.body) { type = getReturnTypeFromBody(getter); } @@ -13259,7 +10767,7 @@ var ts; else if (links.type === resolvingType) { links.type = anyType; if (compilerOptions.noImplicitAny) { - var getter = ts.getDeclarationOfKind(symbol, 137 /* GetAccessor */); + var getter = ts.getDeclarationOfKind(symbol, 137); error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); } } @@ -13267,7 +10775,7 @@ var ts; function getTypeOfFuncClassEnumModule(symbol) { var links = getSymbolLinks(symbol); if (!links.type) { - links.type = createObjectType(32768 /* Anonymous */, symbol); + links.type = createObjectType(32768, symbol); } return links.type; } @@ -13293,28 +10801,28 @@ var ts; return links.type; } function getTypeOfSymbol(symbol) { - if (symbol.flags & 16777216 /* Instantiated */) { + if (symbol.flags & 16777216) { return getTypeOfInstantiatedSymbol(symbol); } - if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) { + if (symbol.flags & (3 | 4)) { return getTypeOfVariableOrParameterOrProperty(symbol); } - if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) { + if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) { return getTypeOfFuncClassEnumModule(symbol); } - if (symbol.flags & 8 /* EnumMember */) { + if (symbol.flags & 8) { return getTypeOfEnumMember(symbol); } - if (symbol.flags & 98304 /* Accessor */) { + if (symbol.flags & 98304) { return getTypeOfAccessors(symbol); } - if (symbol.flags & 8388608 /* Alias */) { + if (symbol.flags & 8388608) { return getTypeOfAlias(symbol); } return unknownType; } function getTargetType(type) { - return type.flags & 4096 /* Reference */ ? type.target : type; + return type.flags & 4096 ? type.target : type; } function hasBaseType(type, checkBase) { return check(type); @@ -13323,13 +10831,10 @@ var ts; return target === checkBase || ts.forEach(getBaseTypes(target), check); } } - // Return combined list of type parameters from all declarations of a class or interface. Elsewhere we check they're all - // the same, but even if they're not we still need the complete list to ensure instantiations supply type arguments - // for all type parameters. function getTypeParametersOfClassOrInterface(symbol) { var result; ts.forEach(symbol.declarations, function (node) { - if (node.kind === 203 /* InterfaceDeclaration */ || node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 203 || node.kind === 202) { var declaration = node; if (declaration.typeParameters && declaration.typeParameters.length) { ts.forEach(declaration.typeParameters, function (node) { @@ -13349,10 +10854,10 @@ var ts; function getBaseTypes(type) { var typeWithBaseTypes = type; if (!typeWithBaseTypes.baseTypes) { - if (type.symbol.flags & 32 /* Class */) { + if (type.symbol.flags & 32) { resolveBaseTypesOfClass(typeWithBaseTypes); } - else if (type.symbol.flags & 64 /* Interface */) { + else if (type.symbol.flags & 64) { resolveBaseTypesOfInterface(typeWithBaseTypes); } else { @@ -13363,17 +10868,17 @@ var ts; } function resolveBaseTypesOfClass(type) { type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(type.symbol, 202 /* ClassDeclaration */); + var declaration = ts.getDeclarationOfKind(type.symbol, 202); var baseTypeNode = ts.getClassExtendsHeritageClauseElement(declaration); if (baseTypeNode) { var baseType = getTypeFromTypeNode(baseTypeNode); if (baseType !== unknownType) { - if (getTargetType(baseType).flags & 1024 /* Class */) { + if (getTargetType(baseType).flags & 1024) { if (type !== baseType && !hasBaseType(baseType, type)) { type.baseTypes.push(baseType); } else { - error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); + error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); } } else { @@ -13386,17 +10891,17 @@ var ts; type.baseTypes = []; for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { var declaration = _a[_i]; - if (declaration.kind === 203 /* InterfaceDeclaration */ && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 203 && ts.getInterfaceBaseTypeNodes(declaration)) { for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) { var node = _c[_b]; var baseType = getTypeFromTypeNode(node); if (baseType !== unknownType) { - if (getTargetType(baseType).flags & (1024 /* Class */ | 2048 /* Interface */)) { + if (getTargetType(baseType).flags & (1024 | 2048)) { if (type !== baseType && !hasBaseType(baseType, type)) { type.baseTypes.push(baseType); } else { - error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); + error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); } } else { @@ -13410,11 +10915,11 @@ var ts; function getDeclaredTypeOfClassOrInterface(symbol) { var links = getSymbolLinks(symbol); if (!links.declaredType) { - var kind = symbol.flags & 32 /* Class */ ? 1024 /* Class */ : 2048 /* Interface */; + var kind = symbol.flags & 32 ? 1024 : 2048; var type = links.declaredType = createObjectType(kind, symbol); var typeParameters = getTypeParametersOfClassOrInterface(symbol); if (typeParameters) { - type.flags |= 4096 /* Reference */; + type.flags |= 4096; type.typeParameters = typeParameters; type.instantiations = {}; type.instantiations[getTypeListId(type.typeParameters)] = type; @@ -13428,7 +10933,7 @@ var ts; var links = getSymbolLinks(symbol); if (!links.declaredType) { links.declaredType = resolvingType; - var declaration = ts.getDeclarationOfKind(symbol, 204 /* TypeAliasDeclaration */); + var declaration = ts.getDeclarationOfKind(symbol, 204); var type = getTypeFromTypeNode(declaration.type); if (links.declaredType === resolvingType) { links.declaredType = type; @@ -13436,7 +10941,7 @@ var ts; } else if (links.declaredType === resolvingType) { links.declaredType = unknownType; - var declaration = ts.getDeclarationOfKind(symbol, 204 /* TypeAliasDeclaration */); + var declaration = ts.getDeclarationOfKind(symbol, 204); error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } return links.declaredType; @@ -13444,7 +10949,7 @@ var ts; function getDeclaredTypeOfEnum(symbol) { var links = getSymbolLinks(symbol); if (!links.declaredType) { - var type = createType(128 /* Enum */); + var type = createType(128); type.symbol = symbol; links.declaredType = type; } @@ -13453,9 +10958,9 @@ var ts; function getDeclaredTypeOfTypeParameter(symbol) { var links = getSymbolLinks(symbol); if (!links.declaredType) { - var type = createType(512 /* TypeParameter */); + var type = createType(512); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 129 /* TypeParameter */).constraint) { + if (!ts.getDeclarationOfKind(symbol, 129).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -13470,20 +10975,20 @@ var ts; return links.declaredType; } function getDeclaredTypeOfSymbol(symbol) { - ts.Debug.assert((symbol.flags & 16777216 /* Instantiated */) === 0); - if (symbol.flags & (32 /* Class */ | 64 /* Interface */)) { + ts.Debug.assert((symbol.flags & 16777216) === 0); + if (symbol.flags & (32 | 64)) { return getDeclaredTypeOfClassOrInterface(symbol); } - if (symbol.flags & 524288 /* TypeAlias */) { + if (symbol.flags & 524288) { return getDeclaredTypeOfTypeAlias(symbol); } - if (symbol.flags & 384 /* Enum */) { + if (symbol.flags & 384) { return getDeclaredTypeOfEnum(symbol); } - if (symbol.flags & 262144 /* TypeParameter */) { + if (symbol.flags & 262144) { return getDeclaredTypeOfTypeParameter(symbol); } - if (symbol.flags & 8388608 /* Alias */) { + if (symbol.flags & 8388608) { return getDeclaredTypeOfAlias(symbol); } return unknownType; @@ -13526,8 +11031,8 @@ var ts; type.declaredProperties = getNamedMembers(symbol.members); type.declaredCallSignatures = getSignaturesOfSymbol(symbol.members["__call"]); type.declaredConstructSignatures = getSignaturesOfSymbol(symbol.members["__new"]); - type.declaredStringIndexType = getIndexTypeOfSymbol(symbol, 0 /* String */); - type.declaredNumberIndexType = getIndexTypeOfSymbol(symbol, 1 /* Number */); + type.declaredStringIndexType = getIndexTypeOfSymbol(symbol, 0); + type.declaredNumberIndexType = getIndexTypeOfSymbol(symbol, 1); } return type; } @@ -13544,10 +11049,10 @@ var ts; for (var _i = 0; _i < baseTypes.length; _i++) { var baseType = baseTypes[_i]; addInheritedMembers(members, getPropertiesOfObjectType(baseType)); - callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(baseType, 0 /* Call */)); - constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(baseType, 1 /* Construct */)); - stringIndexType = stringIndexType || getIndexTypeOfType(baseType, 0 /* String */); - numberIndexType = numberIndexType || getIndexTypeOfType(baseType, 1 /* Number */); + callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(baseType, 0)); + constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(baseType, 1)); + stringIndexType = stringIndexType || getIndexTypeOfType(baseType, 0); + numberIndexType = numberIndexType || getIndexTypeOfType(baseType, 1); } } setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); @@ -13563,10 +11068,10 @@ var ts; ts.forEach(getBaseTypes(target), function (baseType) { var instantiatedBaseType = instantiateType(baseType, mapper); addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType)); - callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* Call */)); - constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1 /* Construct */)); - stringIndexType = stringIndexType || getIndexTypeOfType(instantiatedBaseType, 0 /* String */); - numberIndexType = numberIndexType || getIndexTypeOfType(instantiatedBaseType, 1 /* Number */); + callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0)); + constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1)); + stringIndexType = stringIndexType || getIndexTypeOfType(instantiatedBaseType, 0); + numberIndexType = numberIndexType || getIndexTypeOfType(instantiatedBaseType, 1); }); setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } @@ -13588,9 +11093,9 @@ var ts; var baseTypes = getBaseTypes(classType); if (baseTypes.length) { var baseType = baseTypes[0]; - var baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), 1 /* Construct */); + var baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), 1); return ts.map(baseSignatures, function (baseSignature) { - var signature = baseType.flags & 4096 /* Reference */ ? + var signature = baseType.flags & 4096 ? getSignatureInstantiation(baseSignature, baseType.typeArguments) : cloneSignature(baseSignature); signature.typeParameters = classType.typeParameters; signature.resolvedReturnType = classType; @@ -13602,7 +11107,7 @@ var ts; function createTupleTypeMemberSymbols(memberTypes) { var members = {}; for (var i = 0; i < memberTypes.length; i++) { - var symbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "" + i); + var symbol = createSymbol(4 | 67108864, "" + i); symbol.type = memberTypes[i]; members[i] = symbol; } @@ -13625,9 +11130,6 @@ var ts; } return true; } - // If the lists of call or construct signatures in the given types are all identical except for return types, - // and if none of the signatures are generic, return a list of signatures that has substitutes a union of the - // return types of the corresponding signatures in each resulting signature. function getUnionSignatures(types, kind) { var signatureLists = ts.map(types, function (t) { return getSignaturesOfType(t, kind); }); var signatures = signatureLists[0]; @@ -13645,7 +11147,6 @@ var ts; var result = ts.map(signatures, cloneSignature); for (var i = 0; i < result.length; i++) { var s = result[i]; - // Clear resolved return type we possibly got from cloneSignature s.resolvedReturnType = undefined; s.unionSignatures = ts.map(signatureLists, function (signatures) { return signatures[i]; }); } @@ -13664,12 +11165,10 @@ var ts; return getUnionType(indexTypes); } function resolveUnionTypeMembers(type) { - // The members and properties collections are empty for union types. To get all properties of a union - // type use getPropertiesOfType (only the language service uses this). - var callSignatures = getUnionSignatures(type.types, 0 /* Call */); - var constructSignatures = getUnionSignatures(type.types, 1 /* Construct */); - var stringIndexType = getUnionIndexType(type.types, 0 /* String */); - var numberIndexType = getUnionIndexType(type.types, 1 /* Number */); + var callSignatures = getUnionSignatures(type.types, 0); + var constructSignatures = getUnionSignatures(type.types, 1); + var stringIndexType = getUnionIndexType(type.types, 0); + var numberIndexType = getUnionIndexType(type.types, 1); setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType); } function resolveAnonymousTypeMembers(type) { @@ -13679,25 +11178,24 @@ var ts; var constructSignatures; var stringIndexType; var numberIndexType; - if (symbol.flags & 2048 /* TypeLiteral */) { + if (symbol.flags & 2048) { members = symbol.members; callSignatures = getSignaturesOfSymbol(members["__call"]); constructSignatures = getSignaturesOfSymbol(members["__new"]); - stringIndexType = getIndexTypeOfSymbol(symbol, 0 /* String */); - numberIndexType = getIndexTypeOfSymbol(symbol, 1 /* Number */); + stringIndexType = getIndexTypeOfSymbol(symbol, 0); + numberIndexType = getIndexTypeOfSymbol(symbol, 1); } else { - // Combinations of function, class, enum and module members = emptySymbols; callSignatures = emptyArray; constructSignatures = emptyArray; - if (symbol.flags & 1952 /* HasExports */) { + if (symbol.flags & 1952) { members = getExportsOfSymbol(symbol); } - if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) { + if (symbol.flags & (16 | 8192)) { callSignatures = getSignaturesOfSymbol(symbol); } - if (symbol.flags & 32 /* Class */) { + if (symbol.flags & 32) { var classType = getDeclaredTypeOfClassOrInterface(symbol); constructSignatures = getSignaturesOfSymbol(symbol.members["__constructor"]); if (!constructSignatures.length) { @@ -13710,22 +11208,22 @@ var ts; } } stringIndexType = undefined; - numberIndexType = (symbol.flags & 384 /* Enum */) ? stringType : undefined; + numberIndexType = (symbol.flags & 384) ? stringType : undefined; } setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } function resolveObjectOrUnionTypeMembers(type) { if (!type.members) { - if (type.flags & (1024 /* Class */ | 2048 /* Interface */)) { + if (type.flags & (1024 | 2048)) { resolveClassOrInterfaceMembers(type); } - else if (type.flags & 32768 /* Anonymous */) { + else if (type.flags & 32768) { resolveAnonymousTypeMembers(type); } - else if (type.flags & 8192 /* Tuple */) { + else if (type.flags & 8192) { resolveTupleTypeMembers(type); } - else if (type.flags & 16384 /* Union */) { + else if (type.flags & 16384) { resolveUnionTypeMembers(type); } else { @@ -13734,17 +11232,14 @@ var ts; } return type; } - // Return properties of an object type or an empty array for other types function getPropertiesOfObjectType(type) { - if (type.flags & 48128 /* ObjectType */) { + if (type.flags & 48128) { return resolveObjectOrUnionTypeMembers(type).properties; } return emptyArray; } - // If the given type is an object type and that type has a property by the given name, return - // the symbol for that property. Otherwise return undefined. function getPropertyOfObjectType(type, name) { - if (type.flags & 48128 /* ObjectType */) { + if (type.flags & 48128) { var resolved = resolveObjectOrUnionTypeMembers(type); if (ts.hasProperty(resolved.members, name)) { var symbol = resolved.members[name]; @@ -13766,33 +11261,30 @@ var ts; } function getPropertiesOfType(type) { type = getApparentType(type); - return type.flags & 16384 /* Union */ ? getPropertiesOfUnionType(type) : getPropertiesOfObjectType(type); + return type.flags & 16384 ? getPropertiesOfUnionType(type) : getPropertiesOfObjectType(type); } - // For a type parameter, return the base constraint of the type parameter. For the string, number, - // boolean, and symbol primitive types, return the corresponding object types. Otherwise return the - // type itself. Note that the apparent type of a union type is the union type itself. function getApparentType(type) { - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { type = getReducedTypeOfUnionType(type); } - if (type.flags & 512 /* TypeParameter */) { + if (type.flags & 512) { do { type = getConstraintOfTypeParameter(type); - } while (type && type.flags & 512 /* TypeParameter */); + } while (type && type.flags & 512); if (!type) { type = emptyObjectType; } } - if (type.flags & 258 /* StringLike */) { + if (type.flags & 258) { type = globalStringType; } - else if (type.flags & 132 /* NumberLike */) { + else if (type.flags & 132) { type = globalNumberType; } - else if (type.flags & 8 /* Boolean */) { + else if (type.flags & 8) { type = globalBooleanType; } - else if (type.flags & 1048576 /* ESSymbol */) { + else if (type.flags & 1048576) { type = globalESSymbolType; } return type; @@ -13805,7 +11297,7 @@ var ts; var type = getApparentType(current); if (type !== unknownType) { var prop = getPropertyOfType(type, name); - if (!prop || getDeclarationFlagsFromSymbol(prop) & (32 /* Private */ | 64 /* Protected */)) { + if (!prop || getDeclarationFlagsFromSymbol(prop) & (32 | 64)) { return undefined; } if (!props) { @@ -13825,7 +11317,7 @@ var ts; } propTypes.push(getTypeOfSymbol(prop)); } - var result = createSymbol(4 /* Property */ | 67108864 /* Transient */ | 268435456 /* UnionProperty */, name); + var result = createSymbol(4 | 67108864 | 268435456, name); result.unionType = unionType; result.declarations = declarations; result.type = getUnionType(propTypes); @@ -13842,12 +11334,9 @@ var ts; } return property; } - // Return the symbol for the property with the given name in the given type. Creates synthetic union properties when - // necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from - // Object and Function as appropriate. function getPropertyOfType(type, name) { type = getApparentType(type); - if (type.flags & 48128 /* ObjectType */) { + if (type.flags & 48128) { var resolved = resolveObjectOrUnionTypeMembers(type); if (ts.hasProperty(resolved.members, name)) { var symbol = resolved.members[name]; @@ -13863,26 +11352,24 @@ var ts; } return getPropertyOfObjectType(globalObjectType, name); } - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { return getPropertyOfUnionType(type, name); } return undefined; } function getSignaturesOfObjectOrUnionType(type, kind) { - if (type.flags & (48128 /* ObjectType */ | 16384 /* Union */)) { + if (type.flags & (48128 | 16384)) { var resolved = resolveObjectOrUnionTypeMembers(type); - return kind === 0 /* Call */ ? resolved.callSignatures : resolved.constructSignatures; + return kind === 0 ? resolved.callSignatures : resolved.constructSignatures; } return emptyArray; } - // Return the signatures of the given kind in the given type. Creates synthetic union signatures when necessary and - // maps primitive types and type parameters are to their apparent types. function getSignaturesOfType(type, kind) { return getSignaturesOfObjectOrUnionType(getApparentType(type), kind); } function typeHasCallOrConstructSignatures(type) { var apparentType = getApparentType(type); - if (apparentType.flags & (48128 /* ObjectType */ | 16384 /* Union */)) { + if (apparentType.flags & (48128 | 16384)) { var resolved = resolveObjectOrUnionTypeMembers(type); return resolved.callSignatures.length > 0 || resolved.constructSignatures.length > 0; @@ -13890,18 +11377,14 @@ var ts; return false; } function getIndexTypeOfObjectOrUnionType(type, kind) { - if (type.flags & (48128 /* ObjectType */ | 16384 /* Union */)) { + if (type.flags & (48128 | 16384)) { var resolved = resolveObjectOrUnionTypeMembers(type); - return kind === 0 /* String */ ? resolved.stringIndexType : resolved.numberIndexType; + return kind === 0 ? resolved.stringIndexType : resolved.numberIndexType; } } - // Return the index type of the given kind in the given type. Creates synthetic union index types when necessary and - // maps primitive types and type parameters are to their apparent types. function getIndexTypeOfType(type, kind) { return getIndexTypeOfObjectOrUnionType(getApparentType(type), kind); } - // Return list of type parameters with duplicates removed (duplicate identifier errors are generated in the actual - // type checking functions). function getTypeParametersFromDeclaration(typeParameterDeclarations) { var result = []; ts.forEach(typeParameterDeclarations, function (node) { @@ -13924,7 +11407,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 136 /* Constructor */ ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 136 ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.typeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; @@ -13933,7 +11416,7 @@ var ts; for (var i = 0, n = declaration.parameters.length; i < n; i++) { var param = declaration.parameters[i]; parameters.push(param.symbol); - if (param.type && param.type.kind === 8 /* StringLiteral */) { + if (param.type && param.type.kind === 8) { hasStringLiterals = true; } if (minArgumentCount < 0) { @@ -13953,10 +11436,8 @@ var ts; returnType = getTypeFromTypeNode(declaration.type); } else { - // TypeScript 1.0 spec (April 2014): - // If only one accessor includes a type annotation, the other behaves as if it had the same type annotation. - if (declaration.kind === 137 /* GetAccessor */ && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 138 /* SetAccessor */); + if (declaration.kind === 137 && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 138); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { @@ -13974,22 +11455,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - // Don't include signature if node is the implementation of an overloaded function. A node is considered - // an implementation node if it has a body and the previous node is of the same kind and immediately - // precedes the implementation node (i.e. has the same parent and ends where the implementation starts). + case 143: + case 144: + case 201: + case 135: + case 134: + case 136: + case 139: + case 140: + case 141: + case 137: + case 138: + case 163: + case 164: if (i > 0 && node.body) { var previous = symbol.declarations[i - 1]; if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) { @@ -14034,8 +11512,8 @@ var ts; } function getRestTypeOfSignature(signature) { if (signature.hasRestParameter) { - var type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); - if (type.flags & 4096 /* Reference */ && type.target === globalArrayType) { + var type = getTypeOfSymbol(ts.lastOrUndefined(signature.parameters)); + if (type.flags & 4096 && type.target === globalArrayType) { return type.typeArguments[0]; } } @@ -14058,13 +11536,9 @@ var ts; return signature.erasedSignatureCache; } function getOrCreateTypeFromSignature(signature) { - // There are two ways to declare a construct signature, one is by declaring a class constructor - // using the constructor keyword, and the other is declaring a bare construct signature in an - // object type literal or interface (using the new keyword). Each way of declaring a constructor - // will result in a different declaration kind. if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 136 /* Constructor */ || signature.declaration.kind === 140 /* ConstructSignature */; - var type = createObjectType(32768 /* Anonymous */ | 65536 /* FromSignature */); + var isConstructor = signature.declaration.kind === 136 || signature.declaration.kind === 140; + var type = createObjectType(32768 | 65536); type.members = emptySymbols; type.properties = emptyArray; type.callSignatures = !isConstructor ? [signature] : emptyArray; @@ -14077,7 +11551,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 /* Number */ ? 120 /* NumberKeyword */ : 122 /* StringKeyword */; + var syntaxKind = kind === 1 ? 120 : 122; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -14107,7 +11581,7 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 129 /* TypeParameter */).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 129).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; @@ -14129,22 +11603,19 @@ var ts; return result; } } - // This function is used to propagate widening flags when creating new object types references and union types. - // It is only necessary to do so if a constituent type might be the undefined type, the null type, or the type - // of an object literal (since those types have widening related information we need to track). function getWideningFlagsOfTypes(types) { var result = 0; for (var _i = 0; _i < types.length; _i++) { var type = types[_i]; result |= type.flags; } - return result & 786432 /* RequiresWidening */; + return result & 786432; } function createTypeReference(target, typeArguments) { var id = getTypeListId(typeArguments); var type = target.instantiations[id]; if (!type) { - var flags = 4096 /* Reference */ | getWideningFlagsOfTypes(typeArguments); + var flags = 4096 | getWideningFlagsOfTypes(typeArguments); type = target.instantiations[id] = createObjectType(flags, target.symbol); type.target = target; type.typeArguments = typeArguments; @@ -14156,31 +11627,21 @@ var ts; if (links.isIllegalTypeReferenceInConstraint !== undefined) { return links.isIllegalTypeReferenceInConstraint; } - // bubble up to the declaration var currentNode = typeReferenceNode; - // forEach === exists while (!ts.forEach(typeParameterSymbol.declarations, function (d) { return d.parent === currentNode.parent; })) { currentNode = currentNode.parent; } - // if last step was made from the type parameter this means that path has started somewhere in constraint which is illegal - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 129 /* TypeParameter */; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 129; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 142 /* TypeReference */ && n.typeName.kind === 65 /* Identifier */) { + if (n.kind === 142 && n.typeName.kind === 65) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { - var symbol = resolveName(typeParameter, n.typeName.text, 793056 /* Type */, undefined, undefined); - if (symbol && (symbol.flags & 262144 /* TypeParameter */)) { - // TypeScript 1.0 spec (April 2014): 3.4.1 - // Type parameters declared in a particular type parameter list - // may not be referenced in constraints in that type parameter list - // symbol.declaration.parent === typeParameter.parent - // -> typeParameter and symbol.declaration originate from the same type parameter list - // -> illegal for all declarations in symbol - // forEach === exists + var symbol = resolveName(typeParameter, n.typeName.text, 793056, undefined, undefined); + if (symbol && (symbol.flags & 262144)) { links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent == typeParameter.parent; }); } } @@ -14199,30 +11660,24 @@ var ts; var links = getNodeLinks(node); if (!links.resolvedType) { var type; - // We don't currently support heritage clauses with complex expressions in them. - // For these cases, we just set the type to be the unknownType. - if (node.kind !== 177 /* ExpressionWithTypeArguments */ || ts.isSupportedExpressionWithTypeArguments(node)) { - var typeNameOrExpression = node.kind === 142 /* TypeReference */ + if (node.kind !== 177 || ts.isSupportedExpressionWithTypeArguments(node)) { + var typeNameOrExpression = node.kind === 142 ? node.typeName : node.expression; - var symbol = resolveEntityName(typeNameOrExpression, 793056 /* Type */); + var symbol = resolveEntityName(typeNameOrExpression, 793056); if (symbol) { - if ((symbol.flags & 262144 /* TypeParameter */) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { - // TypeScript 1.0 spec (April 2014): 3.4.1 - // Type parameters declared in a particular type parameter list - // may not be referenced in constraints in that type parameter list - // Implementation: such type references are resolved to 'unknown' type that usually denotes error + if ((symbol.flags & 262144) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { type = unknownType; } else { type = getDeclaredTypeOfSymbol(symbol); - if (type.flags & (1024 /* Class */ | 2048 /* Interface */) && type.flags & 4096 /* Reference */) { + if (type.flags & (1024 | 2048) && type.flags & 4096) { var typeParameters = type.typeParameters; if (node.typeArguments && node.typeArguments.length === typeParameters.length) { type = createTypeReference(type, ts.map(node.typeArguments, getTypeFromTypeNode)); } else { - error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */), typeParameters.length); + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1), typeParameters.length); type = undefined; } } @@ -14242,10 +11697,6 @@ var ts; function getTypeFromTypeQueryNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { - // TypeScript 1.0 spec (April 2014): 3.6.3 - // The expression is processed as an identifier expression (section 4.3) - // or property access expression(section 4.10), - // the widened type(section 3.9) of which becomes the result. links.resolvedType = getWidenedType(checkExpressionOrQualifiedName(node.exprName)); } return links.resolvedType; @@ -14256,9 +11707,9 @@ var ts; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; switch (declaration.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: + case 202: + case 203: + case 205: return declaration; } } @@ -14267,7 +11718,7 @@ var ts; return emptyObjectType; } var type = getDeclaredTypeOfSymbol(symbol); - if (!(type.flags & 48128 /* ObjectType */)) { + if (!(type.flags & 48128)) { error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name); return emptyObjectType; } @@ -14278,10 +11729,10 @@ var ts; return type; } function getGlobalValueSymbol(name) { - return getGlobalSymbol(name, 107455 /* Value */, ts.Diagnostics.Cannot_find_global_value_0); + return getGlobalSymbol(name, 107455, ts.Diagnostics.Cannot_find_global_value_0); } function getGlobalTypeSymbol(name) { - return getGlobalSymbol(name, 793056 /* Type */, ts.Diagnostics.Cannot_find_global_type_0); + return getGlobalSymbol(name, 793056, ts.Diagnostics.Cannot_find_global_type_0); } function getGlobalSymbol(name, meaning, diagnostic) { return resolveName(undefined, name, meaning, diagnostic, name); @@ -14297,9 +11748,6 @@ var ts; return globalIterableType !== emptyObjectType ? createTypeReference(globalIterableType, [elementType]) : emptyObjectType; } function createArrayType(elementType) { - // globalArrayType will be undefined if we get here during creation of the Array type. This for example happens if - // user code augments the Array type with call or construct signatures that have an array type as the return type. - // We instead use globalArraySymbol to obtain the (not yet fully constructed) Array type. var arrayType = globalArrayType || getDeclaredTypeOfSymbol(globalArraySymbol); return arrayType !== emptyObjectType ? createTypeReference(arrayType, [elementType]) : emptyObjectType; } @@ -14314,7 +11762,7 @@ var ts; var id = getTypeListId(elementTypes); var type = tupleTypes[id]; if (!type) { - type = tupleTypes[id] = createObjectType(8192 /* Tuple */); + type = tupleTypes[id] = createObjectType(8192); type.elementTypes = elementTypes; } return type; @@ -14327,7 +11775,7 @@ var ts; return links.resolvedType; } function addTypeToSortedSet(sortedSet, type) { - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { addTypesToSortedSet(sortedSet, type.types); } else { @@ -14368,7 +11816,7 @@ var ts; function containsAnyType(types) { for (var _i = 0; _i < types.length; _i++) { var type = types[_i]; - if (type.flags & 1 /* Any */) { + if (type.flags & 1) { return true; } } @@ -14383,10 +11831,6 @@ var ts; } } } - // The noSubtypeReduction flag is there because it isn't possible to always do subtype reduction. The flag - // is true when creating a union type from a type node and when instantiating a union type. In both of those - // cases subtype reduction has to be deferred to properly support recursive union types. For example, a - // type alias of the form "type Item = string | (() => Item)" cannot be reduced during its declaration. function getUnionType(types, noSubtypeReduction) { if (types.length === 0) { return emptyObjectType; @@ -14409,14 +11853,13 @@ var ts; var id = getTypeListId(sortedTypes); var type = unionTypes[id]; if (!type) { - type = unionTypes[id] = createObjectType(16384 /* Union */ | getWideningFlagsOfTypes(sortedTypes)); + type = unionTypes[id] = createObjectType(16384 | getWideningFlagsOfTypes(sortedTypes)); type.types = sortedTypes; type.reducedType = noSubtypeReduction ? undefined : type; } return type; } function getReducedTypeOfUnionType(type) { - // If union type was created without subtype reduction, perform the deferred reduction now if (!type.reducedType) { type.reducedType = getUnionType(type.types, false); } @@ -14432,8 +11875,7 @@ var ts; function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { - // Deferred resolution of members is handled by resolveObjectTypeMembers - links.resolvedType = createObjectType(32768 /* Anonymous */, node.symbol); + links.resolvedType = createObjectType(32768, node.symbol); } return links.resolvedType; } @@ -14441,7 +11883,7 @@ var ts; if (ts.hasProperty(stringLiteralTypes, node.text)) { return stringLiteralTypes[node.text]; } - var type = stringLiteralTypes[node.text] = createType(256 /* StringLiteral */); + var type = stringLiteralTypes[node.text] = createType(256); type.text = ts.getTextOfNode(node); return type; } @@ -14454,42 +11896,40 @@ var ts; } function getTypeFromTypeNode(node) { switch (node.kind) { - case 112 /* AnyKeyword */: + case 112: return anyType; - case 122 /* StringKeyword */: + case 122: return stringType; - case 120 /* NumberKeyword */: + case 120: return numberType; - case 113 /* BooleanKeyword */: + case 113: return booleanType; - case 123 /* SymbolKeyword */: + case 123: return esSymbolType; - case 99 /* VoidKeyword */: + case 99: return voidType; - case 8 /* StringLiteral */: + case 8: return getTypeFromStringLiteral(node); - case 142 /* TypeReference */: + case 142: return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 177 /* ExpressionWithTypeArguments */: + case 177: return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 145 /* TypeQuery */: + case 145: return getTypeFromTypeQueryNode(node); - case 147 /* ArrayType */: + case 147: return getTypeFromArrayTypeNode(node); - case 148 /* TupleType */: + case 148: return getTypeFromTupleTypeNode(node); - case 149 /* UnionType */: + case 149: return getTypeFromUnionTypeNode(node); - case 150 /* ParenthesizedType */: + case 150: return getTypeFromTypeNode(node.type); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 146 /* TypeLiteral */: + case 143: + case 144: + case 146: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); - // This function assumes that an identifier or qualified name is a type expression - // Callers should first ensure this by calling isTypeNode - case 65 /* Identifier */: - case 127 /* QualifiedName */: + case 65: + case 127: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -14566,7 +12006,7 @@ var ts; return function (t) { return instantiateType(mapper1(t), mapper2); }; } function instantiateTypeParameter(typeParameter, mapper) { - var result = createType(512 /* TypeParameter */); + var result = createType(512); result.symbol = typeParameter.symbol; if (typeParameter.constraint) { result.constraint = instantiateType(typeParameter.constraint, mapper); @@ -14589,17 +12029,12 @@ var ts; return result; } function instantiateSymbol(symbol, mapper) { - if (symbol.flags & 16777216 /* Instantiated */) { + if (symbol.flags & 16777216) { var links = getSymbolLinks(symbol); - // If symbol being instantiated is itself a instantiation, fetch the original target and combine the - // type mappers. This ensures that original type identities are properly preserved and that aliases - // always reference a non-aliases. symbol = links.target; mapper = combineTypeMappers(links.mapper, mapper); } - // Keep the flags from the symbol we're instantiating. Mark that is instantiated, and - // also transient so that we can just store data on it directly. - var result = createSymbol(16777216 /* Instantiated */ | 67108864 /* Transient */ | symbol.flags, symbol.name); + var result = createSymbol(16777216 | 67108864 | symbol.flags, symbol.name); result.declarations = symbol.declarations; result.parent = symbol.parent; result.target = symbol; @@ -14610,13 +12045,13 @@ var ts; return result; } function instantiateAnonymousType(type, mapper) { - var result = createObjectType(32768 /* Anonymous */, type.symbol); + var result = createObjectType(32768, type.symbol); result.properties = instantiateList(getPropertiesOfObjectType(type), mapper, instantiateSymbol); result.members = createSymbolTable(result.properties); - result.callSignatures = instantiateList(getSignaturesOfType(type, 0 /* Call */), mapper, instantiateSignature); - result.constructSignatures = instantiateList(getSignaturesOfType(type, 1 /* Construct */), mapper, instantiateSignature); - var stringIndexType = getIndexTypeOfType(type, 0 /* String */); - var numberIndexType = getIndexTypeOfType(type, 1 /* Number */); + result.callSignatures = instantiateList(getSignaturesOfType(type, 0), mapper, instantiateSignature); + result.constructSignatures = instantiateList(getSignaturesOfType(type, 1), mapper, instantiateSignature); + var stringIndexType = getIndexTypeOfType(type, 0); + var numberIndexType = getIndexTypeOfType(type, 1); if (stringIndexType) result.stringIndexType = instantiateType(stringIndexType, mapper); if (numberIndexType) @@ -14625,49 +12060,47 @@ var ts; } function instantiateType(type, mapper) { if (mapper !== identityMapper) { - if (type.flags & 512 /* TypeParameter */) { + if (type.flags & 512) { return mapper(type); } - if (type.flags & 32768 /* Anonymous */) { - return type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) ? + if (type.flags & 32768) { + return type.symbol && type.symbol.flags & (16 | 8192 | 2048 | 4096) ? instantiateAnonymousType(type, mapper) : type; } - if (type.flags & 4096 /* Reference */) { + if (type.flags & 4096) { return createTypeReference(type.target, instantiateList(type.typeArguments, mapper, instantiateType)); } - if (type.flags & 8192 /* Tuple */) { + if (type.flags & 8192) { return createTupleType(instantiateList(type.elementTypes, mapper, instantiateType)); } - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { return getUnionType(instantiateList(type.types, mapper, instantiateType), true); } } return type; } - // Returns true if the given expression contains (at any level of nesting) a function or arrow expression - // that is subject to contextual typing. function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 163: + case 164: return isContextSensitiveFunctionLikeDeclaration(node); - case 155 /* ObjectLiteralExpression */: + case 155: return ts.forEach(node.properties, isContextSensitive); - case 154 /* ArrayLiteralExpression */: + case 154: return ts.forEach(node.elements, isContextSensitive); - case 171 /* ConditionalExpression */: + case 171: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 170 /* BinaryExpression */: - return node.operatorToken.kind === 49 /* BarBarToken */ && + case 170: + return node.operatorToken.kind === 49 && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 225 /* PropertyAssignment */: + case 225: return isContextSensitive(node.initializer); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: return isContextSensitiveFunctionLikeDeclaration(node); - case 162 /* ParenthesizedExpression */: + case 162: return isContextSensitive(node.expression); } return false; @@ -14676,10 +12109,10 @@ var ts; return !node.typeParameters && node.parameters.length && !ts.forEach(node.parameters, function (p) { return p.type; }); } function getTypeWithoutConstructors(type) { - if (type.flags & 48128 /* ObjectType */) { + if (type.flags & 48128) { var resolved = resolveObjectOrUnionTypeMembers(type); if (resolved.constructSignatures.length) { - var result = createObjectType(32768 /* Anonymous */, type.symbol); + var result = createObjectType(32768, type.symbol); result.members = resolved.members; result.properties = resolved.properties; result.callSignatures = resolved.callSignatures; @@ -14689,7 +12122,6 @@ var ts; } return type; } - // TYPE CHECKING var subtypeRelation = {}; var assignableRelation = {}; var identityRelation = {}; @@ -14697,7 +12129,7 @@ var ts; return checkTypeRelatedTo(source, target, identityRelation, undefined); } function compareTypes(source, target) { - return checkTypeRelatedTo(source, target, identityRelation, undefined) ? -1 /* True */ : 0 /* False */; + return checkTypeRelatedTo(source, target, identityRelation, undefined) ? -1 : 0; } function isTypeSubtypeOf(source, target) { return checkTypeSubtypeOf(source, target, undefined); @@ -14731,10 +12163,6 @@ var ts; error(errorNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target)); } else if (errorInfo) { - // If we already computed this relation, but in a context where we didn't want to report errors (e.g. overload resolution), - // then we'll only have a top-level error (e.g. 'Class X does not implement interface Y') without any details. If this happened, - // request a recompuation to get a complete error message. This will be skipped if we've already done this computation in a context - // where errors were being reported. if (errorInfo.next === undefined) { errorInfo = undefined; elaborateErrors = true; @@ -14745,48 +12173,43 @@ var ts; } diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo)); } - return result !== 0 /* False */; + return result !== 0; function reportError(message, arg0, arg1, arg2) { errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); } - // Compare two types and return - // Ternary.True if they are related with no assumptions, - // Ternary.Maybe if they are related with assumptions of other relationships, or - // Ternary.False if they are not related. function isRelatedTo(source, target, reportErrors, headMessage) { var result; - // both types are the same - covers 'they are the same primitive type or both are Any' or the same type parameter cases if (source === target) - return -1 /* True */; + return -1; if (relation !== identityRelation) { - if (target.flags & 1 /* Any */) - return -1 /* True */; + if (target.flags & 1) + return -1; if (source === undefinedType) - return -1 /* True */; + return -1; if (source === nullType && target !== undefinedType) - return -1 /* True */; - if (source.flags & 128 /* Enum */ && target === numberType) - return -1 /* True */; - if (source.flags & 256 /* StringLiteral */ && target === stringType) - return -1 /* True */; + return -1; + if (source.flags & 128 && target === numberType) + return -1; + if (source.flags & 256 && target === stringType) + return -1; if (relation === assignableRelation) { - if (source.flags & 1 /* Any */) - return -1 /* True */; - if (source === numberType && target.flags & 128 /* Enum */) - return -1 /* True */; + if (source.flags & 1) + return -1; + if (source === numberType && target.flags & 128) + return -1; } } var saveErrorInfo = errorInfo; - if (source.flags & 16384 /* Union */ || target.flags & 16384 /* Union */) { + if (source.flags & 16384 || target.flags & 16384) { if (relation === identityRelation) { - if (source.flags & 16384 /* Union */ && target.flags & 16384 /* Union */) { + if (source.flags & 16384 && target.flags & 16384) { if (result = unionTypeRelatedToUnionType(source, target)) { if (result &= unionTypeRelatedToUnionType(target, source)) { return result; } } } - else if (source.flags & 16384 /* Union */) { + else if (source.flags & 16384) { if (result = unionTypeRelatedToType(source, target, reportErrors)) { return result; } @@ -14798,7 +12221,7 @@ var ts; } } else { - if (source.flags & 16384 /* Union */) { + if (source.flags & 16384) { if (result = unionTypeRelatedToType(source, target, reportErrors)) { return result; } @@ -14810,32 +12233,25 @@ var ts; } } } - else if (source.flags & 512 /* TypeParameter */ && target.flags & 512 /* TypeParameter */) { + else if (source.flags & 512 && target.flags & 512) { if (result = typeParameterRelatedTo(source, target, reportErrors)) { return result; } } - else if (source.flags & 4096 /* Reference */ && target.flags & 4096 /* Reference */ && source.target === target.target) { - // We have type references to same target type, see if relationship holds for all type arguments + else if (source.flags & 4096 && target.flags & 4096 && source.target === target.target) { if (result = typesRelatedTo(source.typeArguments, target.typeArguments, reportErrors)) { return result; } } - // Even if relationship doesn't hold for unions, type parameters, or generic type references, - // it may hold in a structural comparison. - // Report structural errors only if we haven't reported any errors yet var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo; - // identity relation does not use apparent type var sourceOrApparentType = relation === identityRelation ? source : getApparentType(source); - if (sourceOrApparentType.flags & 48128 /* ObjectType */ && target.flags & 48128 /* ObjectType */) { + if (sourceOrApparentType.flags & 48128 && target.flags & 48128) { if (result = objectTypeRelatedTo(sourceOrApparentType, target, reportStructuralErrors)) { errorInfo = saveErrorInfo; return result; } } - else if (source.flags & 512 /* TypeParameter */ && sourceOrApparentType.flags & 16384 /* Union */) { - // We clear the errors first because the following check often gives a better error than - // the union comparison above if it is applicable. + else if (source.flags & 512 && sourceOrApparentType.flags & 16384) { errorInfo = saveErrorInfo; if (result = isRelatedTo(sourceOrApparentType, target, reportErrors)) { return result; @@ -14846,21 +12262,21 @@ var ts; var sourceType = typeToString(source); var targetType = typeToString(target); if (sourceType === targetType) { - sourceType = typeToString(source, undefined, 128 /* UseFullyQualifiedType */); - targetType = typeToString(target, undefined, 128 /* UseFullyQualifiedType */); + sourceType = typeToString(source, undefined, 128); + targetType = typeToString(target, undefined, 128); } reportError(headMessage, sourceType, targetType); } - return 0 /* False */; + return 0; } function unionTypeRelatedToUnionType(source, target) { - var result = -1 /* True */; + var result = -1; var sourceTypes = source.types; for (var _i = 0; _i < sourceTypes.length; _i++) { var sourceType = sourceTypes[_i]; var related = typeRelatedToUnionType(sourceType, target, false); if (!related) { - return 0 /* False */; + return 0; } result &= related; } @@ -14874,27 +12290,27 @@ var ts; return related; } } - return 0 /* False */; + return 0; } function unionTypeRelatedToType(source, target, reportErrors) { - var result = -1 /* True */; + var result = -1; var sourceTypes = source.types; for (var _i = 0; _i < sourceTypes.length; _i++) { var sourceType = sourceTypes[_i]; var related = isRelatedTo(sourceType, target, reportErrors); if (!related) { - return 0 /* False */; + return 0; } result &= related; } return result; } function typesRelatedTo(sources, targets, reportErrors) { - var result = -1 /* True */; + var result = -1; for (var i = 0, len = sources.length; i < len; i++) { var related = isRelatedTo(sources[i], targets[i], reportErrors); if (!related) { - return 0 /* False */; + return 0; } result &= related; } @@ -14903,14 +12319,13 @@ var ts; function typeParameterRelatedTo(source, target, reportErrors) { if (relation === identityRelation) { if (source.symbol.name !== target.symbol.name) { - return 0 /* False */; + return 0; } - // covers case when both type parameters does not have constraint (both equal to noConstraintType) if (source.constraint === target.constraint) { - return -1 /* True */; + return -1; } if (source.constraint === noConstraintType || target.constraint === noConstraintType) { - return 0 /* False */; + return 0; } return isRelatedTo(source.constraint, target.constraint, reportErrors); } @@ -14918,43 +12333,34 @@ var ts; while (true) { var constraint = getConstraintOfTypeParameter(source); if (constraint === target) - return -1 /* True */; - if (!(constraint && constraint.flags & 512 /* TypeParameter */)) + return -1; + if (!(constraint && constraint.flags & 512)) break; source = constraint; } - return 0 /* False */; + return 0; } } - // Determine if two object types are related by structure. First, check if the result is already available in the global cache. - // Second, check if we have already started a comparison of the given two types in which case we assume the result to be true. - // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are - // equal and infinitely expanding. Fourth, if we have reached a depth of 100 nested comparisons, assume we have runaway recursion - // and issue an error. Otherwise, actually compare the structure of the two types. function objectTypeRelatedTo(source, target, reportErrors) { if (overflow) { - return 0 /* False */; + return 0; } var id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id; var related = relation[id]; - //let related: RelationComparisonResult = undefined; // relation[id]; if (related !== undefined) { - // If we computed this relation already and it was failed and reported, or if we're not being asked to elaborate - // errors, we can use the cached value. Otherwise, recompute the relation - if (!elaborateErrors || (related === 3 /* FailedAndReported */)) { - return related === 1 /* Succeeded */ ? -1 /* True */ : 0 /* False */; + if (!elaborateErrors || (related === 3)) { + return related === 1 ? -1 : 0; } } if (depth > 0) { for (var i = 0; i < depth; i++) { - // If source and target are already being compared, consider them related with assumptions if (maybeStack[i][id]) { - return 1 /* Maybe */; + return 1; } } if (depth === 100) { overflow = true; - return 0 /* False */; + return 0; } } else { @@ -14966,7 +12372,7 @@ var ts; sourceStack[depth] = source; targetStack[depth] = target; maybeStack[depth] = {}; - maybeStack[depth][id] = 1 /* Succeeded */; + maybeStack[depth][id] = 1; depth++; var saveExpandingFlags = expandingFlags; if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) @@ -14975,14 +12381,14 @@ var ts; expandingFlags |= 2; var result; if (expandingFlags === 3) { - result = 1 /* Maybe */; + result = 1; } else { result = propertiesRelatedTo(source, target, reportErrors); if (result) { - result &= signaturesRelatedTo(source, target, 0 /* Call */, reportErrors); + result &= signaturesRelatedTo(source, target, 0, reportErrors); if (result) { - result &= signaturesRelatedTo(source, target, 1 /* Construct */, reportErrors); + result &= signaturesRelatedTo(source, target, 1, reportErrors); if (result) { result &= stringIndexTypesRelatedTo(source, target, reportErrors); if (result) { @@ -14996,29 +12402,21 @@ var ts; depth--; if (result) { var maybeCache = maybeStack[depth]; - // If result is definitely true, copy assumptions to global cache, else copy to next level up - var destinationCache = (result === -1 /* True */ || depth === 0) ? relation : maybeStack[depth - 1]; + var destinationCache = (result === -1 || depth === 0) ? relation : maybeStack[depth - 1]; ts.copyMap(maybeCache, destinationCache); } else { - // A false result goes straight into global cache (when something is false under assumptions it - // will also be false without assumptions) - relation[id] = reportErrors ? 3 /* FailedAndReported */ : 2 /* Failed */; + relation[id] = reportErrors ? 3 : 2; } return result; } - // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case - // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible, - // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding. - // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at - // some level beyond that. function isDeeplyNestedGeneric(type, stack) { - if (type.flags & 4096 /* Reference */ && depth >= 10) { + if (type.flags & 4096 && depth >= 10) { var target_1 = type.target; var count = 0; for (var i = 0; i < depth; i++) { var t = stack[i]; - if (t.flags & 4096 /* Reference */ && t.target === target_1) { + if (t.flags & 4096 && t.target === target_1) { count++; if (count >= 10) return true; @@ -15031,74 +12429,67 @@ var ts; if (relation === identityRelation) { return propertiesIdenticalTo(source, target); } - var result = -1 /* True */; + var result = -1; var properties = getPropertiesOfObjectType(target); - var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 131072 /* ObjectLiteral */); + var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 131072); for (var _i = 0; _i < properties.length; _i++) { var targetProp = properties[_i]; var sourceProp = getPropertyOfType(source, targetProp.name); if (sourceProp !== targetProp) { if (!sourceProp) { - if (!(targetProp.flags & 536870912 /* Optional */) || requireOptionalProperties) { + if (!(targetProp.flags & 536870912) || requireOptionalProperties) { if (reportErrors) { reportError(ts.Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source)); } - return 0 /* False */; + return 0; } } - else if (!(targetProp.flags & 134217728 /* Prototype */)) { + else if (!(targetProp.flags & 134217728)) { var sourceFlags = getDeclarationFlagsFromSymbol(sourceProp); var targetFlags = getDeclarationFlagsFromSymbol(targetProp); - if (sourceFlags & 32 /* Private */ || targetFlags & 32 /* Private */) { + if (sourceFlags & 32 || targetFlags & 32) { if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) { if (reportErrors) { - if (sourceFlags & 32 /* Private */ && targetFlags & 32 /* Private */) { + if (sourceFlags & 32 && targetFlags & 32) { reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp)); } else { - reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourceFlags & 32 /* Private */ ? source : target), typeToString(sourceFlags & 32 /* Private */ ? target : source)); + reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourceFlags & 32 ? source : target), typeToString(sourceFlags & 32 ? target : source)); } } - return 0 /* False */; + return 0; } } - else if (targetFlags & 64 /* Protected */) { - var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32 /* Class */; + else if (targetFlags & 64) { + var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32; var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined; var targetClass = getDeclaredTypeOfSymbol(targetProp.parent); if (!sourceClass || !hasBaseType(sourceClass, targetClass)) { if (reportErrors) { reportError(ts.Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(sourceClass || source), typeToString(targetClass)); } - return 0 /* False */; + return 0; } } - else if (sourceFlags & 64 /* Protected */) { + else if (sourceFlags & 64) { if (reportErrors) { reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); } - return 0 /* False */; + return 0; } var related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors); if (!related) { if (reportErrors) { reportError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp)); } - return 0 /* False */; + return 0; } result &= related; - if (sourceProp.flags & 536870912 /* Optional */ && !(targetProp.flags & 536870912 /* Optional */)) { - // TypeScript 1.0 spec (April 2014): 3.8.3 - // S is a subtype of a type T, and T is a supertype of S if ... - // S' and T are object types and, for each member M in T.. - // M is a property and S' contains a property N where - // if M is a required property, N is also a required property - // (M - property in T) - // (N - property in S) + if (sourceProp.flags & 536870912 && !(targetProp.flags & 536870912)) { if (reportErrors) { reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); } - return 0 /* False */; + return 0; } } } @@ -15109,18 +12500,18 @@ var ts; var sourceProperties = getPropertiesOfObjectType(source); var targetProperties = getPropertiesOfObjectType(target); if (sourceProperties.length !== targetProperties.length) { - return 0 /* False */; + return 0; } - var result = -1 /* True */; + var result = -1; for (var _i = 0; _i < sourceProperties.length; _i++) { var sourceProp = sourceProperties[_i]; var targetProp = getPropertyOfObjectType(target, sourceProp.name); if (!targetProp) { - return 0 /* False */; + return 0; } var related = compareProperties(sourceProp, targetProp, isRelatedTo); if (!related) { - return 0 /* False */; + return 0; } result &= related; } @@ -15131,40 +12522,39 @@ var ts; return signaturesIdenticalTo(source, target, kind); } if (target === anyFunctionType || source === anyFunctionType) { - return -1 /* True */; + return -1; } var sourceSignatures = getSignaturesOfType(source, kind); var targetSignatures = getSignaturesOfType(target, kind); - var result = -1 /* True */; + var result = -1; var saveErrorInfo = errorInfo; outer: for (var _i = 0; _i < targetSignatures.length; _i++) { var t = targetSignatures[_i]; - if (!t.hasStringLiterals || target.flags & 65536 /* FromSignature */) { + if (!t.hasStringLiterals || target.flags & 65536) { var localErrors = reportErrors; for (var _a = 0; _a < sourceSignatures.length; _a++) { var s = sourceSignatures[_a]; - if (!s.hasStringLiterals || source.flags & 65536 /* FromSignature */) { + if (!s.hasStringLiterals || source.flags & 65536) { var related = signatureRelatedTo(s, t, localErrors); if (related) { result &= related; errorInfo = saveErrorInfo; continue outer; } - // Only report errors from the first failure localErrors = false; } } - return 0 /* False */; + return 0; } } return result; } function signatureRelatedTo(source, target, reportErrors) { if (source === target) { - return -1 /* True */; + return -1; } if (!target.hasRestParameter && source.minArgumentCount > target.parameters.length) { - return 0 /* False */; + return 0; } var sourceMax = source.parameters.length; var targetMax = target.parameters.length; @@ -15185,11 +12575,9 @@ var ts; else { checkCount = sourceMax < targetMax ? sourceMax : targetMax; } - // Spec 1.0 Section 3.8.3 & 3.8.4: - // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N source = getErasedSignature(source); target = getErasedSignature(target); - var result = -1 /* True */; + var result = -1; for (var i = 0; i < checkCount; i++) { var s_1 = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source); var t_1 = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target); @@ -15201,7 +12589,7 @@ var ts; if (reportErrors) { reportError(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible, source.parameters[i < sourceMax ? i : sourceMax].name, target.parameters[i < targetMax ? i : targetMax].name); } - return 0 /* False */; + return 0; } errorInfo = saveErrorInfo; } @@ -15217,13 +12605,13 @@ var ts; var sourceSignatures = getSignaturesOfType(source, kind); var targetSignatures = getSignaturesOfType(target, kind); if (sourceSignatures.length !== targetSignatures.length) { - return 0 /* False */; + return 0; } - var result = -1 /* True */; + var result = -1; for (var i = 0, len = sourceSignatures.length; i < len; ++i) { var related = compareSignatures(sourceSignatures[i], targetSignatures[i], true, isRelatedTo); if (!related) { - return 0 /* False */; + return 0; } result &= related; } @@ -15231,45 +12619,44 @@ var ts; } function stringIndexTypesRelatedTo(source, target, reportErrors) { if (relation === identityRelation) { - return indexTypesIdenticalTo(0 /* String */, source, target); + return indexTypesIdenticalTo(0, source, target); } - var targetType = getIndexTypeOfType(target, 0 /* String */); + var targetType = getIndexTypeOfType(target, 0); if (targetType) { - var sourceType = getIndexTypeOfType(source, 0 /* String */); + var sourceType = getIndexTypeOfType(source, 0); if (!sourceType) { if (reportErrors) { reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source)); } - return 0 /* False */; + return 0; } var related = isRelatedTo(sourceType, targetType, reportErrors); if (!related) { if (reportErrors) { reportError(ts.Diagnostics.Index_signatures_are_incompatible); } - return 0 /* False */; + return 0; } return related; } - return -1 /* True */; + return -1; } function numberIndexTypesRelatedTo(source, target, reportErrors) { if (relation === identityRelation) { - return indexTypesIdenticalTo(1 /* Number */, source, target); + return indexTypesIdenticalTo(1, source, target); } - var targetType = getIndexTypeOfType(target, 1 /* Number */); + var targetType = getIndexTypeOfType(target, 1); if (targetType) { - var sourceStringType = getIndexTypeOfType(source, 0 /* String */); - var sourceNumberType = getIndexTypeOfType(source, 1 /* Number */); + var sourceStringType = getIndexTypeOfType(source, 0); + var sourceNumberType = getIndexTypeOfType(source, 1); if (!(sourceStringType || sourceNumberType)) { if (reportErrors) { reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source)); } - return 0 /* False */; + return 0; } var related; if (sourceStringType && sourceNumberType) { - // If we know for sure we're testing both string and numeric index types then only report errors from the second one related = isRelatedTo(sourceStringType, targetType, false) || isRelatedTo(sourceNumberType, targetType, reportErrors); } else { @@ -15279,78 +12666,73 @@ var ts; if (reportErrors) { reportError(ts.Diagnostics.Index_signatures_are_incompatible); } - return 0 /* False */; + return 0; } return related; } - return -1 /* True */; + return -1; } function indexTypesIdenticalTo(indexKind, source, target) { var targetType = getIndexTypeOfType(target, indexKind); var sourceType = getIndexTypeOfType(source, indexKind); if (!sourceType && !targetType) { - return -1 /* True */; + return -1; } if (sourceType && targetType) { return isRelatedTo(sourceType, targetType); } - return 0 /* False */; + return 0; } } function isPropertyIdenticalTo(sourceProp, targetProp) { - return compareProperties(sourceProp, targetProp, compareTypes) !== 0 /* False */; + return compareProperties(sourceProp, targetProp, compareTypes) !== 0; } function compareProperties(sourceProp, targetProp, compareTypes) { - // Two members are considered identical when - // - they are public properties with identical names, optionality, and types, - // - they are private or protected properties originating in the same declaration and having identical types if (sourceProp === targetProp) { - return -1 /* True */; + return -1; } - var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (32 /* Private */ | 64 /* Protected */); - var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (32 /* Private */ | 64 /* Protected */); + var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (32 | 64); + var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (32 | 64); if (sourcePropAccessibility !== targetPropAccessibility) { - return 0 /* False */; + return 0; } if (sourcePropAccessibility) { if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) { - return 0 /* False */; + return 0; } } else { - if ((sourceProp.flags & 536870912 /* Optional */) !== (targetProp.flags & 536870912 /* Optional */)) { - return 0 /* False */; + if ((sourceProp.flags & 536870912) !== (targetProp.flags & 536870912)) { + return 0; } } return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp)); } function compareSignatures(source, target, compareReturnTypes, compareTypes) { if (source === target) { - return -1 /* True */; + return -1; } if (source.parameters.length !== target.parameters.length || source.minArgumentCount !== target.minArgumentCount || source.hasRestParameter !== target.hasRestParameter) { - return 0 /* False */; + return 0; } - var result = -1 /* True */; + var result = -1; if (source.typeParameters && target.typeParameters) { if (source.typeParameters.length !== target.typeParameters.length) { - return 0 /* False */; + return 0; } for (var i = 0, len = source.typeParameters.length; i < len; ++i) { var related = compareTypes(source.typeParameters[i], target.typeParameters[i]); if (!related) { - return 0 /* False */; + return 0; } result &= related; } } else if (source.typeParameters || target.typeParameters) { - return 0 /* False */; + return 0; } - // Spec 1.0 Section 3.8.3 & 3.8.4: - // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N source = getErasedSignature(source); target = getErasedSignature(target); for (var i = 0, len = source.parameters.length; i < len; i++) { @@ -15358,7 +12740,7 @@ var ts; var t = target.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]); var related = compareTypes(s, t); if (!related) { - return 0 /* False */; + return 0; } result &= related; } @@ -15379,9 +12761,6 @@ var ts; return ts.forEach(types, function (t) { return isSupertypeOfEach(t, types) ? t : undefined; }); } function reportNoCommonSupertypeError(types, errorLocation, errorMessageChainHead) { - // The downfallType/bestSupertypeDownfallType is the first type that caused a particular candidate - // to not be the common supertype. So if it weren't for this one downfallType (and possibly others), - // the type in question could have been the common supertype. var bestSupertype; var bestSupertypeDownfallType; var bestSupertypeScore = 0; @@ -15402,31 +12781,23 @@ var ts; bestSupertypeDownfallType = downfallType; bestSupertypeScore = score; } - // types.length - 1 is the maximum score, given that getCommonSupertype returned false if (bestSupertypeScore === types.length - 1) { break; } } - // In the following errors, the {1} slot is before the {0} slot because checkTypeSubtypeOf supplies the - // subtype as the first argument to the error checkTypeSubtypeOf(bestSupertypeDownfallType, bestSupertype, errorLocation, ts.Diagnostics.Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0, errorMessageChainHead); } function isArrayType(type) { - return type.flags & 4096 /* Reference */ && type.target === globalArrayType; + return type.flags & 4096 && type.target === globalArrayType; } function isArrayLikeType(type) { - // A type is array-like if it is not the undefined or null type and if it is assignable to any[] - return !(type.flags & (32 /* Undefined */ | 64 /* Null */)) && isTypeAssignableTo(type, anyArrayType); + return !(type.flags & (32 | 64)) && isTypeAssignableTo(type, anyArrayType); } function isTupleLikeType(type) { return !!getPropertyOfType(type, "0"); } - /** - * Check if a Type was written as a tuple type literal. - * Prefer using isTupleLikeType() unless the use of `elementTypes` is required. - */ function isTupleType(type) { - return (type.flags & 8192 /* Tuple */) && !!type.elementTypes; + return (type.flags & 8192) && !!type.elementTypes; } function getWidenedTypeOfObjectLiteral(type) { var properties = getPropertiesOfObjectType(type); @@ -15435,7 +12806,7 @@ var ts; var propType = getTypeOfSymbol(p); var widenedType = getWidenedType(propType); if (propType !== widenedType) { - var symbol = createSymbol(p.flags | 67108864 /* Transient */, p.name); + var symbol = createSymbol(p.flags | 67108864, p.name); symbol.declarations = p.declarations; symbol.parent = p.parent; symbol.type = widenedType; @@ -15446,8 +12817,8 @@ var ts; } members[p.name] = p; }); - var stringIndexType = getIndexTypeOfType(type, 0 /* String */); - var numberIndexType = getIndexTypeOfType(type, 1 /* Number */); + var stringIndexType = getIndexTypeOfType(type, 0); + var numberIndexType = getIndexTypeOfType(type, 1); if (stringIndexType) stringIndexType = getWidenedType(stringIndexType); if (numberIndexType) @@ -15455,14 +12826,14 @@ var ts; return createAnonymousType(type.symbol, members, emptyArray, emptyArray, stringIndexType, numberIndexType); } function getWidenedType(type) { - if (type.flags & 786432 /* RequiresWidening */) { - if (type.flags & (32 /* Undefined */ | 64 /* Null */)) { + if (type.flags & 786432) { + if (type.flags & (32 | 64)) { return anyType; } - if (type.flags & 131072 /* ObjectLiteral */) { + if (type.flags & 131072) { return getWidenedTypeOfObjectLiteral(type); } - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { return getUnionType(ts.map(type.types, getWidenedType)); } if (isArrayType(type)) { @@ -15472,7 +12843,7 @@ var ts; return type; } function reportWideningErrorsInType(type) { - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { var errorReported = false; ts.forEach(type.types, function (t) { if (reportWideningErrorsInType(t)) { @@ -15484,11 +12855,11 @@ var ts; if (isArrayType(type)) { return reportWideningErrorsInType(type.typeArguments[0]); } - if (type.flags & 131072 /* ObjectLiteral */) { + if (type.flags & 131072) { var errorReported = false; ts.forEach(getPropertiesOfObjectType(type), function (p) { var t = getTypeOfSymbol(p); - if (t.flags & 262144 /* ContainsUndefinedOrNull */) { + if (t.flags & 262144) { if (!reportWideningErrorsInType(t)) { error(p.valueDeclaration, ts.Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(getWidenedType(t))); } @@ -15503,22 +12874,22 @@ var ts; var typeAsString = typeToString(getWidenedType(type)); var diagnostic; switch (declaration.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 133: + case 132: diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; break; - case 130 /* Parameter */: + case 130: diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; break; - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 201: + case 135: + case 134: + case 137: + case 138: + case 163: + case 164: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -15531,8 +12902,7 @@ var ts; error(declaration, diagnostic, ts.declarationNameToString(declaration.name), typeAsString); } function reportErrorsFromWidening(declaration, type) { - if (produceDiagnostics && compilerOptions.noImplicitAny && type.flags & 262144 /* ContainsUndefinedOrNull */) { - // Report implicit any error within type if possible, otherwise report error on declaration + if (produceDiagnostics && compilerOptions.noImplicitAny && type.flags & 262144) { if (!reportWideningErrorsInType(type)) { reportImplicitAnyError(declaration, type); } @@ -15597,7 +12967,7 @@ var ts; var count = 0; for (var i = 0; i < depth; i++) { var t = stack[i]; - if (t.flags & 4096 /* Reference */ && t.target === target_2) { + if (t.flags & 4096 && t.target === target_2) { count++; } } @@ -15609,19 +12979,12 @@ var ts; if (source === anyFunctionType) { return; } - if (target.flags & 512 /* TypeParameter */) { - // If target is a type parameter, make an inference + if (target.flags & 512) { var typeParameters = context.typeParameters; for (var i = 0; i < typeParameters.length; i++) { if (target === typeParameters[i]) { var inferences = context.inferences[i]; if (!inferences.isFixed) { - // Any inferences that are made to a type parameter in a union type are inferior - // to inferences made to a flat (non-union) type. This is because if we infer to - // T | string[], we really don't know if we should be inferring to T or not (because - // the correct constituent on the target side could be string[]). Therefore, we put - // such inferior inferences into a secondary bucket, and only use them if the primary - // bucket is empty. var candidates = inferiority ? inferences.secondary || (inferences.secondary = []) : inferences.primary || (inferences.primary = []); @@ -15633,22 +12996,20 @@ var ts; } } } - else if (source.flags & 4096 /* Reference */ && target.flags & 4096 /* Reference */ && source.target === target.target) { - // If source and target are references to the same generic type, infer from type arguments + else if (source.flags & 4096 && target.flags & 4096 && source.target === target.target) { var sourceTypes = source.typeArguments; var targetTypes = target.typeArguments; for (var i = 0; i < sourceTypes.length; i++) { inferFromTypes(sourceTypes[i], targetTypes[i]); } } - else if (target.flags & 16384 /* Union */) { + else if (target.flags & 16384) { var targetTypes = target.types; var typeParameterCount = 0; var typeParameter; - // First infer to each type in union that isn't a type parameter for (var _i = 0; _i < targetTypes.length; _i++) { var t = targetTypes[_i]; - if (t.flags & 512 /* TypeParameter */ && ts.contains(context.typeParameters, t)) { + if (t.flags & 512 && ts.contains(context.typeParameters, t)) { typeParameter = t; typeParameterCount++; } @@ -15656,24 +13017,21 @@ var ts; inferFromTypes(source, t); } } - // If union contains a single naked type parameter, make a secondary inference to that type parameter if (typeParameterCount === 1) { inferiority++; inferFromTypes(source, typeParameter); inferiority--; } } - else if (source.flags & 16384 /* Union */) { - // Source is a union type, infer from each consituent type + else if (source.flags & 16384) { var sourceTypes = source.types; for (var _a = 0; _a < sourceTypes.length; _a++) { var sourceType = sourceTypes[_a]; inferFromTypes(sourceType, target); } } - else if (source.flags & 48128 /* ObjectType */ && (target.flags & (4096 /* Reference */ | 8192 /* Tuple */) || - (target.flags & 32768 /* Anonymous */) && target.symbol && target.symbol.flags & (8192 /* Method */ | 2048 /* TypeLiteral */))) { - // If source is an object type, and target is a type reference, a tuple type, the type of a method, or a type literal, infer from members + else if (source.flags & 48128 && (target.flags & (4096 | 8192) || + (target.flags & 32768) && target.symbol && target.symbol.flags & (8192 | 2048))) { if (!isInProcess(source, target) && isWithinDepthLimit(source, sourceStack) && isWithinDepthLimit(target, targetStack)) { if (depth === 0) { sourceStack = []; @@ -15683,11 +13041,11 @@ var ts; targetStack[depth] = target; depth++; inferFromProperties(source, target); - inferFromSignatures(source, target, 0 /* Call */); - inferFromSignatures(source, target, 1 /* Construct */); - inferFromIndexTypes(source, target, 0 /* String */, 0 /* String */); - inferFromIndexTypes(source, target, 1 /* Number */, 1 /* Number */); - inferFromIndexTypes(source, target, 0 /* String */, 1 /* Number */); + inferFromSignatures(source, target, 0); + inferFromSignatures(source, target, 1); + inferFromIndexTypes(source, target, 0, 0); + inferFromIndexTypes(source, target, 1, 1); + inferFromIndexTypes(source, target, 0, 1); depth--; } } @@ -15736,28 +13094,19 @@ var ts; if (!inferredType) { var inferences = getInferenceCandidates(context, index); if (inferences.length) { - // Infer widened union or supertype, or the unknown type for no common supertype var unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences); inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : unknownType; inferenceSucceeded = !!unionOrSuperType; } else { - // Infer the empty object type when no inferences were made. It is important to remember that - // in this case, inference still succeeds, meaning there is no error for not having inference - // candidates. An inference error only occurs when there are *conflicting* candidates, i.e. - // candidates with no common supertype. inferredType = emptyObjectType; inferenceSucceeded = true; } - // Only do the constraint check if inference succeeded (to prevent cascading errors) if (inferenceSucceeded) { var constraint = getConstraintOfTypeParameter(context.typeParameters[index]); inferredType = constraint && !isTypeAssignableTo(inferredType, constraint) ? constraint : inferredType; } else if (context.failedTypeParameterIndex === undefined || context.failedTypeParameterIndex > index) { - // If inference failed, it is necessary to record the index of the failed type parameter (the one we are on). - // It might be that inference has already failed on a later type parameter on a previous call to inferTypeArguments. - // So if this failure is on preceding type parameter, this type parameter is the new failure index. context.failedTypeParameterIndex = index; } context.inferredTypes[index] = inferredType; @@ -15773,24 +13122,20 @@ var ts; function hasAncestor(node, kind) { return ts.getAncestor(node, kind) !== undefined; } - // EXPRESSION TYPE CHECKING function getResolvedSymbol(node) { var links = getNodeLinks(node); if (!links.resolvedSymbol) { - links.resolvedSymbol = (!ts.nodeIsMissing(node) && resolveName(node, node.text, 107455 /* Value */ | 1048576 /* ExportValue */, ts.Diagnostics.Cannot_find_name_0, node)) || unknownSymbol; + links.resolvedSymbol = (!ts.nodeIsMissing(node) && resolveName(node, node.text, 107455 | 1048576, ts.Diagnostics.Cannot_find_name_0, node)) || unknownSymbol; } return links.resolvedSymbol; } function isInTypeQuery(node) { - // TypeScript 1.0 spec (April 2014): 3.6.3 - // A type query consists of the keyword typeof followed by an expression. - // The expression is restricted to a single identifier or a sequence of identifiers separated by periods while (node) { switch (node.kind) { - case 145 /* TypeQuery */: + case 145: return true; - case 65 /* Identifier */: - case 127 /* QualifiedName */: + case 65: + case 127: node = node.parent; continue; default: @@ -15799,13 +13144,10 @@ var ts; } ts.Debug.fail("should not get here"); } - // For a union type, remove all constituent types that are of the given type kind (when isOfTypeKind is true) - // or not of the given type kind (when isOfTypeKind is false) function removeTypesFromUnionType(type, typeKind, isOfTypeKind, allowEmptyUnionResult) { - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { var types = type.types; if (ts.forEach(types, function (t) { return !!(t.flags & typeKind) === isOfTypeKind; })) { - // Above we checked if we have anything to remove, now use the opposite test to do the removal var narrowedType = getUnionType(ts.filter(types, function (t) { return !(t.flags & typeKind) === isOfTypeKind; })); if (allowEmptyUnionResult || narrowedType !== emptyObjectType) { return narrowedType; @@ -15813,8 +13155,6 @@ var ts; } } else if (allowEmptyUnionResult && !!(type.flags & typeKind) === isOfTypeKind) { - // Use getUnionType(emptyArray) instead of emptyObjectType in case the way empty union types - // are represented ever changes. return getUnionType(emptyArray); } return type; @@ -15822,7 +13162,6 @@ var ts; function hasInitializer(node) { return !!(node.initializer || ts.isBindingPattern(node.parent) && hasInitializer(node.parent.parent)); } - // Check if a given variable is assigned within a given syntax node function isVariableAssignedWithin(symbol, node) { var links = getNodeLinks(node); if (links.assignmentChecks) { @@ -15836,12 +13175,12 @@ var ts; } return links.assignmentChecks[symbol.id] = isAssignedIn(node); function isAssignedInBinaryExpression(node) { - if (node.operatorToken.kind >= 53 /* FirstAssignment */ && node.operatorToken.kind <= 64 /* LastAssignment */) { + if (node.operatorToken.kind >= 53 && node.operatorToken.kind <= 64) { var n = node.left; - while (n.kind === 162 /* ParenthesizedExpression */) { + while (n.kind === 162) { n = n.expression; } - if (n.kind === 65 /* Identifier */ && getResolvedSymbol(n) === symbol) { + if (n.kind === 65 && getResolvedSymbol(n) === symbol) { return true; } } @@ -15855,54 +13194,52 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 170 /* BinaryExpression */: + case 170: return isAssignedInBinaryExpression(node); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 199: + case 153: return isAssignedInVariableDeclaration(node); - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 168 /* PrefixUnaryExpression */: - case 165 /* DeleteExpression */: - case 166 /* TypeOfExpression */: - case 167 /* VoidExpression */: - case 169 /* PostfixUnaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 180 /* Block */: - case 181 /* VariableStatement */: - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 192 /* ReturnStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 196 /* ThrowStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: + case 151: + case 152: + case 154: + case 155: + case 156: + case 157: + case 158: + case 159: + case 161: + case 162: + case 168: + case 165: + case 166: + case 167: + case 169: + case 171: + case 174: + case 180: + case 181: + case 183: + case 184: + case 185: + case 186: + case 187: + case 188: + case 189: + case 192: + case 193: + case 194: + case 221: + case 222: + case 195: + case 196: + case 197: + case 224: return ts.forEachChild(node, isAssignedIn); } return false; } } function resolveLocation(node) { - // Resolve location from top down towards node if it is a context sensitive expression - // That helps in making sure not assigning types as any when resolved out of order var containerNodes = []; for (var parent_3 = node.parent; parent_3; parent_3 = parent_3.parent) { if ((ts.isExpression(parent_3) || ts.isObjectLiteralMethod(node)) && @@ -15922,65 +13259,46 @@ var ts; } function getTypeOfSymbolAtLocation(symbol, node) { resolveLocation(node); - // Get the narrowed type of symbol at given location instead of just getting - // the type of the symbol. - // eg. - // function foo(a: string | number) { - // if (typeof a === "string") { - // a/**/ - // } - // } - // getTypeOfSymbol for a would return type of parameter symbol string | number - // Unless we provide location /**/, checker wouldn't know how to narrow the type - // By using getNarrowedTypeOfSymbol would return string since it would be able to narrow - // it by typeguard in the if true condition return getNarrowedTypeOfSymbol(symbol, node); } - // Get the narrowed type of a given symbol at a given location function getNarrowedTypeOfSymbol(symbol, node) { var type = getTypeOfSymbol(symbol); - // Only narrow when symbol is variable of type any or an object, union, or type parameter type - if (node && symbol.flags & 3 /* Variable */ && type.flags & (1 /* Any */ | 48128 /* ObjectType */ | 16384 /* Union */ | 512 /* TypeParameter */)) { + if (node && symbol.flags & 3 && type.flags & (1 | 48128 | 16384 | 512)) { loop: while (node.parent) { var child = node; node = node.parent; var narrowedType = type; switch (node.kind) { - case 184 /* IfStatement */: - // In a branch of an if statement, narrow based on controlling expression + case 184: if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 171 /* ConditionalExpression */: - // In a branch of a conditional expression, narrow based on controlling condition + case 171: if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 170 /* BinaryExpression */: - // In the right operand of an && or ||, narrow based on left operand + case 170: if (child === node.right) { - if (node.operatorToken.kind === 48 /* AmpersandAmpersandToken */) { + if (node.operatorToken.kind === 48) { narrowedType = narrowType(type, node.left, true); } - else if (node.operatorToken.kind === 49 /* BarBarToken */) { + else if (node.operatorToken.kind === 49) { narrowedType = narrowType(type, node.left, false); } } break; - case 228 /* SourceFile */: - case 206 /* ModuleDeclaration */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - // Stop at the first containing function or module declaration + case 228: + case 206: + case 201: + case 135: + case 134: + case 137: + case 138: + case 136: break loop; } - // Use narrowed type if construct contains no assignments to variable if (narrowedType !== type) { if (isVariableAssignedWithin(symbol, node)) { break; @@ -15991,50 +13309,39 @@ var ts; } return type; function narrowTypeByEquality(type, expr, assumeTrue) { - // Check that we have 'typeof ' on the left and string literal on the right - if (expr.left.kind !== 166 /* TypeOfExpression */ || expr.right.kind !== 8 /* StringLiteral */) { + if (expr.left.kind !== 166 || expr.right.kind !== 8) { return type; } var left = expr.left; var right = expr.right; - if (left.expression.kind !== 65 /* Identifier */ || getResolvedSymbol(left.expression) !== symbol) { + if (left.expression.kind !== 65 || getResolvedSymbol(left.expression) !== symbol) { return type; } var typeInfo = primitiveTypeInfo[right.text]; - if (expr.operatorToken.kind === 31 /* ExclamationEqualsEqualsToken */) { + if (expr.operatorToken.kind === 31) { assumeTrue = !assumeTrue; } if (assumeTrue) { - // Assumed result is true. If check was not for a primitive type, remove all primitive types if (!typeInfo) { - return removeTypesFromUnionType(type, 258 /* StringLike */ | 132 /* NumberLike */ | 8 /* Boolean */ | 1048576 /* ESSymbol */, - /*isOfTypeKind*/ true, false); + return removeTypesFromUnionType(type, 258 | 132 | 8 | 1048576, true, false); } - // Check was for a primitive type, return that primitive type if it is a subtype if (isTypeSubtypeOf(typeInfo.type, type)) { return typeInfo.type; } - // Otherwise, remove all types that aren't of the primitive type kind. This can happen when the type is - // union of enum types and other types. return removeTypesFromUnionType(type, typeInfo.flags, false, false); } else { - // Assumed result is false. If check was for a primitive type, remove that primitive type if (typeInfo) { return removeTypesFromUnionType(type, typeInfo.flags, true, false); } - // Otherwise we don't have enough information to do anything. return type; } } function narrowTypeByAnd(type, expr, assumeTrue) { if (assumeTrue) { - // The assumed result is true, therefore we narrow assuming each operand to be true. return narrowType(narrowType(type, expr.left, true), expr.right, true); } else { - // The assumed result is false. This means either the first operand was false, or the first operand was true - // and the second operand was false. We narrow with those assumptions and union the two resulting types. return getUnionType([ narrowType(type, expr.left, false), narrowType(narrowType(type, expr.left, true), expr.right, false) @@ -16043,67 +13350,57 @@ var ts; } function narrowTypeByOr(type, expr, assumeTrue) { if (assumeTrue) { - // The assumed result is true. This means either the first operand was true, or the first operand was false - // and the second operand was true. We narrow with those assumptions and union the two resulting types. return getUnionType([ narrowType(type, expr.left, true), narrowType(narrowType(type, expr.left, false), expr.right, true) ]); } else { - // The assumed result is false, therefore we narrow assuming each operand to be false. return narrowType(narrowType(type, expr.left, false), expr.right, false); } } function narrowTypeByInstanceof(type, expr, assumeTrue) { - // Check that type is not any, assumed result is true, and we have variable symbol on the left - if (type.flags & 1 /* Any */ || !assumeTrue || expr.left.kind !== 65 /* Identifier */ || getResolvedSymbol(expr.left) !== symbol) { + if (type.flags & 1 || !assumeTrue || expr.left.kind !== 65 || getResolvedSymbol(expr.left) !== symbol) { return type; } - // Check that right operand is a function type with a prototype property var rightType = checkExpression(expr.right); if (!isTypeSubtypeOf(rightType, globalFunctionType)) { return type; } - // Target type is type of prototype property var prototypeProperty = getPropertyOfType(rightType, "prototype"); if (!prototypeProperty) { return type; } var targetType = getTypeOfSymbol(prototypeProperty); - // Narrow to target type if it is a subtype of current type if (isTypeSubtypeOf(targetType, type)) { return targetType; } - // If current type is a union type, remove all constituents that aren't subtypes of target type - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { return getUnionType(ts.filter(type.types, function (t) { return isTypeSubtypeOf(t, targetType); })); } return type; } - // Narrow the given type based on the given expression having the assumed boolean value. The returned type - // will be a subtype or the same type as the argument. function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 162 /* ParenthesizedExpression */: + case 162: return narrowType(type, expr.expression, assumeTrue); - case 170 /* BinaryExpression */: + case 170: var operator = expr.operatorToken.kind; - if (operator === 30 /* EqualsEqualsEqualsToken */ || operator === 31 /* ExclamationEqualsEqualsToken */) { + if (operator === 30 || operator === 31) { return narrowTypeByEquality(type, expr, assumeTrue); } - else if (operator === 48 /* AmpersandAmpersandToken */) { + else if (operator === 48) { return narrowTypeByAnd(type, expr, assumeTrue); } - else if (operator === 49 /* BarBarToken */) { + else if (operator === 49) { return narrowTypeByOr(type, expr, assumeTrue); } - else if (operator === 87 /* InstanceOfKeyword */) { + else if (operator === 87) { return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 168 /* PrefixUnaryExpression */: - if (expr.operator === 46 /* ExclamationToken */) { + case 168: + if (expr.operator === 46) { return narrowType(type, expr.operand, !assumeTrue); } break; @@ -16113,16 +13410,10 @@ var ts; } function checkIdentifier(node) { var symbol = getResolvedSymbol(node); - // As noted in ECMAScript 6 language spec, arrow functions never have an arguments objects. - // Although in down-level emit of arrow function, we emit it using function expression which means that - // arguments objects will be bound to the inner object; emitting arrow function natively in ES6, arguments objects - // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior. - // To avoid that we will give an error to users if they use arguments objects in arrow function so that they - // can explicitly bound arguments objects - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 164 /* ArrowFunction */ && languageVersion < 2 /* ES6 */) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 164 && languageVersion < 2) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } - if (symbol.flags & 8388608 /* Alias */ && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { + if (symbol.flags & 8388608 && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { markAliasSymbolAsReferenced(symbol); } checkCollisionWithCapturedSuperVariable(node, node); @@ -16141,24 +13432,17 @@ var ts; return false; } function checkBlockScopedBindingCapturedInLoop(node, symbol) { - if (languageVersion >= 2 /* ES6 */ || - (symbol.flags & 2 /* BlockScopedVariable */) === 0 || - symbol.valueDeclaration.parent.kind === 224 /* CatchClause */) { + if (languageVersion >= 2 || + (symbol.flags & 2) === 0 || + symbol.valueDeclaration.parent.kind === 224) { return; } - // - check if binding is used in some function - // (stop the walk when reaching container of binding declaration) - // - if first check succeeded - check if variable is declared inside the loop - // nesting structure: - // (variable declaration or binding element) -> variable declaration list -> container var container = symbol.valueDeclaration; - while (container.kind !== 200 /* VariableDeclarationList */) { + while (container.kind !== 200) { container = container.parent; } - // get the parent of variable declaration list container = container.parent; - if (container.kind === 181 /* VariableStatement */) { - // if parent is variable statement - get its parent + if (container.kind === 181) { container = container.parent; } var inFunction = isInsideFunction(node.parent, container); @@ -16168,79 +13452,72 @@ var ts; if (inFunction) { grammarErrorOnFirstToken(current, ts.Diagnostics.Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher, ts.declarationNameToString(node)); } - // mark value declaration so during emit they can have a special handling - getNodeLinks(symbol.valueDeclaration).flags |= 256 /* BlockScopedBindingInLoop */; + getNodeLinks(symbol.valueDeclaration).flags |= 256; break; } current = current.parent; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 202 /* ClassDeclaration */ ? container.parent : undefined; - getNodeLinks(node).flags |= 2 /* LexicalThis */; - if (container.kind === 133 /* PropertyDeclaration */ || container.kind === 136 /* Constructor */) { - getNodeLinks(classNode).flags |= 4 /* CaptureThis */; + var classNode = container.parent && container.parent.kind === 202 ? container.parent : undefined; + getNodeLinks(node).flags |= 2; + if (container.kind === 133 || container.kind === 136) { + getNodeLinks(classNode).flags |= 4; } else { - getNodeLinks(container).flags |= 4 /* CaptureThis */; + getNodeLinks(container).flags |= 4; } } function checkThisExpression(node) { - // Stop at the first arrow function so that we can - // tell whether 'this' needs to be captured. var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; - // Now skip arrow functions to get the "real" owner of 'this'. - if (container.kind === 164 /* ArrowFunction */) { + if (container.kind === 164) { container = ts.getThisContainer(container, false); - // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code - needToCaptureLexicalThis = (languageVersion < 2 /* ES6 */); + needToCaptureLexicalThis = (languageVersion < 2); } switch (container.kind) { - case 206 /* ModuleDeclaration */: + case 206: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body); - // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks break; - case 205 /* EnumDeclaration */: + case 205: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); - // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks break; - case 136 /* Constructor */: + case 136: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - if (container.flags & 128 /* Static */) { + case 133: + case 132: + if (container.flags & 128) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 128 /* ComputedPropertyName */: + case 128: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name); break; } if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 202 /* ClassDeclaration */ ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 202 ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); - return container.flags & 128 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); + return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); } return anyType; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 130 /* Parameter */) { + if (n.kind === 130) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 158 /* CallExpression */ && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 202 /* ClassDeclaration */); + var isCallExpression = node.parent.kind === 158 && node.parent.expression === node; + var enclosingClass = ts.getAncestor(node, 202); var baseClass; if (enclosingClass && ts.getClassExtendsHeritageClauseElement(enclosingClass)) { var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); @@ -16256,67 +13533,55 @@ var ts; var canUseSuperExpression = false; var needToCaptureLexicalThis; if (isCallExpression) { - // TS 1.0 SPEC (April 2014): 4.8.1 - // Super calls are only permitted in constructors of derived classes - canUseSuperExpression = container.kind === 136 /* Constructor */; + canUseSuperExpression = container.kind === 136; } else { - // TS 1.0 SPEC (April 2014) - // 'super' property access is allowed - // - In a constructor, instance member function, instance member accessor, or instance member variable initializer where this references a derived class instance - // - In a static member function or static member accessor - // super property access might appear in arrow functions with arbitrary deep nesting needToCaptureLexicalThis = false; - while (container && container.kind === 164 /* ArrowFunction */) { + while (container && container.kind === 164) { container = ts.getSuperContainer(container, true); - needToCaptureLexicalThis = languageVersion < 2 /* ES6 */; + needToCaptureLexicalThis = languageVersion < 2; } - // topmost container must be something that is directly nested in the class declaration - if (container && container.parent && container.parent.kind === 202 /* ClassDeclaration */) { - if (container.flags & 128 /* Static */) { + if (container && container.parent && container.parent.kind === 202) { + if (container.flags & 128) { canUseSuperExpression = - container.kind === 135 /* MethodDeclaration */ || - container.kind === 134 /* MethodSignature */ || - container.kind === 137 /* GetAccessor */ || - container.kind === 138 /* SetAccessor */; + container.kind === 135 || + container.kind === 134 || + container.kind === 137 || + container.kind === 138; } else { canUseSuperExpression = - container.kind === 135 /* MethodDeclaration */ || - container.kind === 134 /* MethodSignature */ || - container.kind === 137 /* GetAccessor */ || - container.kind === 138 /* SetAccessor */ || - container.kind === 133 /* PropertyDeclaration */ || - container.kind === 132 /* PropertySignature */ || - container.kind === 136 /* Constructor */; + container.kind === 135 || + container.kind === 134 || + container.kind === 137 || + container.kind === 138 || + container.kind === 133 || + container.kind === 132 || + container.kind === 136; } } } if (canUseSuperExpression) { var returnType; - if ((container.flags & 128 /* Static */) || isCallExpression) { - getNodeLinks(node).flags |= 32 /* SuperStatic */; + if ((container.flags & 128) || isCallExpression) { + getNodeLinks(node).flags |= 32; returnType = getTypeOfSymbol(baseClass.symbol); } else { - getNodeLinks(node).flags |= 16 /* SuperInstance */; + getNodeLinks(node).flags |= 16; returnType = baseClass; } - if (container.kind === 136 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) { - // issue custom error message for super property access in constructor arguments (to be aligned with old compiler) + if (container.kind === 136 && isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; } if (!isCallExpression && needToCaptureLexicalThis) { - // call expressions are allowed only in constructors so they should always capture correct 'this' - // super property access expressions can also appear in arrow functions - - // in this case they should also use correct lexical this captureLexicalThis(node.parent, container); } return returnType; } } - if (container && container.kind === 128 /* ComputedPropertyName */) { + if (container && container.kind === 128) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -16327,7 +13592,6 @@ var ts; } return unknownType; } - // Return contextual type of parameter or undefined if no contextual type is available function getContextuallyTypedParameterType(parameter) { if (isFunctionExpressionOrArrowFunction(parameter.parent)) { var func = parameter.parent; @@ -16340,28 +13604,22 @@ var ts; if (indexOfParameter < len) { return getTypeAtPosition(contextualSignature, indexOfParameter); } - // If last parameter is contextually rest parameter get its type if (indexOfParameter === (func.parameters.length - 1) && funcHasRestParameters && contextualSignature.hasRestParameter && func.parameters.length >= contextualSignature.parameters.length) { - return getTypeOfSymbol(contextualSignature.parameters[contextualSignature.parameters.length - 1]); + return getTypeOfSymbol(ts.lastOrUndefined(contextualSignature.parameters)); } } } } return undefined; } - // In a variable, parameter or property declaration with a type annotation, the contextual type of an initializer - // expression is the type of the variable, parameter or property. Otherwise, in a parameter declaration of a - // contextually typed function expression, the contextual type of an initializer expression is the contextual type - // of the parameter. Otherwise, in a variable or parameter declaration with a binding pattern name, the contextual - // type of an initializer expression is the type implied by the binding pattern. function getContextualTypeForInitializerExpression(node) { var declaration = node.parent; if (node === declaration.initializer) { if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130 /* Parameter */) { + if (declaration.kind === 130) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -16376,13 +13634,9 @@ var ts; function getContextualTypeForReturnExpression(node) { var func = ts.getContainingFunction(node); if (func) { - // If the containing function has a return type annotation, is a constructor, or is a get accessor whose - // corresponding set accessor has a type annotation, return statements in the function are contextually typed - if (func.type || func.kind === 136 /* Constructor */ || func.kind === 137 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 138 /* SetAccessor */))) { + if (func.type || func.kind === 136 || func.kind === 137 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 138))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(func)); } - // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature - // and that call signature is non-generic, return statements are contextually typed by the return type of the signature var signature = getContextualSignatureForFunctionLikeDeclaration(func); if (signature) { return getReturnTypeOfSignature(signature); @@ -16390,7 +13644,6 @@ var ts; } return undefined; } - // In a typed function call, an argument or substitution expression is contextually typed by the type of the corresponding parameter. function getContextualTypeForArgument(callTarget, arg) { var args = getEffectiveCallArguments(callTarget); var argIndex = ts.indexOf(args, arg); @@ -16401,7 +13654,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 160 /* TaggedTemplateExpression */) { + if (template.parent.kind === 160) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -16409,15 +13662,12 @@ var ts; function getContextualTypeForBinaryOperand(node) { var binaryExpression = node.parent; var operator = binaryExpression.operatorToken.kind; - if (operator >= 53 /* FirstAssignment */ && operator <= 64 /* LastAssignment */) { - // In an assignment expression, the right operand is contextually typed by the type of the left operand. + if (operator >= 53 && operator <= 64) { if (node === binaryExpression.right) { return checkExpression(binaryExpression.left); } } - else if (operator === 49 /* BarBarToken */) { - // When an || expression has a contextual type, the operands are contextually typed by that type. When an || - // expression has no contextual type, the right operand is contextually typed by the type of the left operand. + else if (operator === 49) { var type = getContextualType(binaryExpression); if (!type && node === binaryExpression.right) { type = checkExpression(binaryExpression.left); @@ -16426,11 +13676,8 @@ var ts; } return undefined; } - // Apply a mapping function to a contextual type and return the resulting type. If the contextual type - // is a union type, the mapping function is applied to each constituent type and a union of the resulting - // types is returned. function applyToContextualType(type, mapper) { - if (!(type.flags & 16384 /* Union */)) { + if (!(type.flags & 16384)) { return mapper(type); } var types = type.types; @@ -16462,21 +13709,15 @@ var ts; function getIndexTypeOfContextualType(type, kind) { return applyToContextualType(type, function (t) { return getIndexTypeOfObjectOrUnionType(t, kind); }); } - // Return true if the given contextual type is a tuple-like type function contextualTypeIsTupleLikeType(type) { - return !!(type.flags & 16384 /* Union */ ? ts.forEach(type.types, isTupleLikeType) : isTupleLikeType(type)); + return !!(type.flags & 16384 ? ts.forEach(type.types, isTupleLikeType) : isTupleLikeType(type)); } - // Return true if the given contextual type provides an index signature of the given kind function contextualTypeHasIndexSignature(type, kind) { - return !!(type.flags & 16384 /* Union */ ? ts.forEach(type.types, function (t) { return getIndexTypeOfObjectOrUnionType(t, kind); }) : getIndexTypeOfObjectOrUnionType(type, kind)); + return !!(type.flags & 16384 ? ts.forEach(type.types, function (t) { return getIndexTypeOfObjectOrUnionType(t, kind); }) : getIndexTypeOfObjectOrUnionType(type, kind)); } - // In an object literal contextually typed by a type T, the contextual type of a property assignment is the type of - // the matching property in T, if one exists. Otherwise, it is the type of the numeric index signature in T, if one - // exists. Otherwise, it is the type of the string index signature in T, if one exists. function getContextualTypeForObjectLiteralMethod(node) { ts.Debug.assert(ts.isObjectLiteralMethod(node)); if (isInsideWithStatementBody(node)) { - // We cannot answer semantic questions within a with block, do not proceed any further return undefined; } return getContextualTypeForObjectLiteralElement(node); @@ -16486,45 +13727,34 @@ var ts; var type = getContextualType(objectLiteral); if (type) { if (!ts.hasDynamicName(element)) { - // For a (non-symbol) computed property, there is no reason to look up the name - // in the type. It will just be "__computed", which does not appear in any - // SymbolTable. var symbolName = getSymbolOfNode(element).name; var propertyType = getTypeOfPropertyOfContextualType(type, symbolName); if (propertyType) { return propertyType; } } - return isNumericName(element.name) && getIndexTypeOfContextualType(type, 1 /* Number */) || - getIndexTypeOfContextualType(type, 0 /* String */); + return isNumericName(element.name) && getIndexTypeOfContextualType(type, 1) || + getIndexTypeOfContextualType(type, 0); } return undefined; } - // In an array literal contextually typed by a type T, the contextual type of an element expression at index N is - // the type of the property with the numeric name N in T, if one exists. Otherwise, if T has a numeric index signature, - // it is the type of the numeric index signature in T. Otherwise, in ES6 and higher, the contextual type is the iterated - // type of T. function getContextualTypeForElementExpression(node) { var arrayLiteral = node.parent; var type = getContextualType(arrayLiteral); if (type) { var index = ts.indexOf(arrayLiteral.elements, node); return getTypeOfPropertyOfContextualType(type, "" + index) - || getIndexTypeOfContextualType(type, 1 /* Number */) - || (languageVersion >= 2 /* ES6 */ ? checkIteratedType(type, undefined) : undefined); + || getIndexTypeOfContextualType(type, 1) + || (languageVersion >= 2 ? checkIteratedType(type, undefined) : undefined); } return undefined; } - // In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type. function getContextualTypeForConditionalOperand(node) { var conditional = node.parent; return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined; } - // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily - // be "pushed" onto a node using the contextualType property. function getContextualType(node) { if (isInsideWithStatementBody(node)) { - // We cannot answer semantic questions within a with block, do not proceed any further return undefined; } if (node.contextualType) { @@ -16532,40 +13762,38 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 199 /* VariableDeclaration */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 153 /* BindingElement */: + case 199: + case 130: + case 133: + case 132: + case 153: return getContextualTypeForInitializerExpression(node); - case 164 /* ArrowFunction */: - case 192 /* ReturnStatement */: + case 164: + case 192: return getContextualTypeForReturnExpression(node); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 158: + case 159: return getContextualTypeForArgument(parent, node); - case 161 /* TypeAssertionExpression */: + case 161: return getTypeFromTypeNode(parent.type); - case 170 /* BinaryExpression */: + case 170: return getContextualTypeForBinaryOperand(node); - case 225 /* PropertyAssignment */: + case 225: return getContextualTypeForObjectLiteralElement(parent); - case 154 /* ArrayLiteralExpression */: + case 154: return getContextualTypeForElementExpression(node); - case 171 /* ConditionalExpression */: + case 171: return getContextualTypeForConditionalOperand(node); - case 178 /* TemplateSpan */: - ts.Debug.assert(parent.parent.kind === 172 /* TemplateExpression */); + case 178: + ts.Debug.assert(parent.parent.kind === 172); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 162 /* ParenthesizedExpression */: + case 162: return getContextualType(parent); } return undefined; } - // If the given type is an object or union type, if that type has a single signature, and if - // that signature is non-generic, return the signature. Otherwise return undefined. function getNonGenericSignature(type) { - var signatures = getSignaturesOfObjectOrUnionType(type, 0 /* Call */); + var signatures = getSignaturesOfObjectOrUnionType(type, 0); if (signatures.length === 1) { var signature = signatures[0]; if (!signature.typeParameters) { @@ -16574,92 +13802,68 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 163 /* FunctionExpression */ || node.kind === 164 /* ArrowFunction */; + return node.kind === 163 || node.kind === 164; } function getContextualSignatureForFunctionLikeDeclaration(node) { - // Only function expressions and arrow functions are contextually typed. return isFunctionExpressionOrArrowFunction(node) ? getContextualSignature(node) : undefined; } - // Return the contextual signature for a given expression node. A contextual type provides a - // contextual signature if it has a single call signature and if that call signature is non-generic. - // If the contextual type is a union type, get the signature from each type possible and if they are - // all identical ignoring their return type, the result is same signature but with return type as - // union type of return types from these signatures function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); if (!type) { return undefined; } - if (!(type.flags & 16384 /* Union */)) { + if (!(type.flags & 16384)) { return getNonGenericSignature(type); } var signatureList; var types = type.types; for (var _i = 0; _i < types.length; _i++) { var current = types[_i]; - // The signature set of all constituent type with call signatures should match - // So number of signatures allowed is either 0 or 1 if (signatureList && - getSignaturesOfObjectOrUnionType(current, 0 /* Call */).length > 1) { + getSignaturesOfObjectOrUnionType(current, 0).length > 1) { return undefined; } var signature = getNonGenericSignature(current); if (signature) { if (!signatureList) { - // This signature will contribute to contextual union signature signatureList = [signature]; } else if (!compareSignatures(signatureList[0], signature, false, compareTypes)) { - // Signatures aren't identical, do not use return undefined; } else { - // Use this signature for contextual union signature signatureList.push(signature); } } } - // Result is union of signatures collected (return type is union of return types of this signature set) var result; if (signatureList) { result = cloneSignature(signatureList[0]); - // Clear resolved return type we possibly got from cloneSignature result.resolvedReturnType = undefined; result.unionSignatures = signatureList; } return result; } - // Presence of a contextual type mapper indicates inferential typing, except the identityMapper object is - // used as a special marker for other purposes. function isInferentialContext(mapper) { return mapper && mapper !== identityMapper; } - // A node is an assignment target if it is on the left hand side of an '=' token, if it is parented by a property - // assignment in an object literal that is an assignment target, or if it is parented by an array literal that is - // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ p: a}] = xxx'. function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 170 /* BinaryExpression */ && parent.operatorToken.kind === 53 /* EqualsToken */ && parent.left === node) { + if (parent.kind === 170 && parent.operatorToken.kind === 53 && parent.left === node) { return true; } - if (parent.kind === 225 /* PropertyAssignment */) { + if (parent.kind === 225) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 154 /* ArrayLiteralExpression */) { + if (parent.kind === 154) { return isAssignmentTarget(parent); } return false; } function checkSpreadElementExpression(node, contextualMapper) { - // It is usually not safe to call checkExpressionCached if we can be contextually typing. - // You can tell that we are contextually typing because of the contextualMapper parameter. - // While it is true that a spread element can have a contextual type, it does not do anything - // with this type. It is neither affected by it, nor does it propagate it to its operand. - // So the fact that contextualMapper is passed is not important, because the operand of a spread - // element is not contextually typed. var arrayOrIterableType = checkExpressionCached(node.expression, contextualMapper); return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, false); } @@ -16673,22 +13877,10 @@ var ts; var inDestructuringPattern = isAssignmentTarget(node); for (var _i = 0; _i < elements.length; _i++) { var e = elements[_i]; - if (inDestructuringPattern && e.kind === 174 /* SpreadElementExpression */) { - // Given the following situation: - // var c: {}; - // [...c] = ["", 0]; - // - // c is represented in the tree as a spread element in an array literal. - // But c really functions as a rest element, and its purpose is to provide - // a contextual type for the right hand side of the assignment. Therefore, - // instead of calling checkExpression on "...c", which will give an error - // if c is not iterable/array-like, we need to act as if we are trying to - // get the contextual element type from it. So we do something similar to - // getContextualTypeForElementExpression, which will crucially not error - // if there is no index type / iterated type. + if (inDestructuringPattern && e.kind === 174) { var restArrayType = checkExpression(e.expression, contextualMapper); - var restElementType = getIndexTypeOfType(restArrayType, 1 /* Number */) || - (languageVersion >= 2 /* ES6 */ ? checkIteratedType(restArrayType, undefined) : undefined); + var restElementType = getIndexTypeOfType(restArrayType, 1) || + (languageVersion >= 2 ? checkIteratedType(restArrayType, undefined) : undefined); if (restElementType) { elementTypes.push(restElementType); } @@ -16697,7 +13889,7 @@ var ts; var type = checkExpression(e, contextualMapper); elementTypes.push(type); } - hasSpreadElement = hasSpreadElement || e.kind === 174 /* SpreadElementExpression */; + hasSpreadElement = hasSpreadElement || e.kind === 174; } if (!hasSpreadElement) { var contextualType = getContextualType(node); @@ -16708,44 +13900,19 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 128 /* ComputedPropertyName */ ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 128 ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { - // It seems odd to consider an expression of type Any to result in a numeric name, - // but this behavior is consistent with checkIndexedAccess - return allConstituentTypesHaveKind(checkComputedPropertyName(name), 1 /* Any */ | 132 /* NumberLike */); + return allConstituentTypesHaveKind(checkComputedPropertyName(name), 1 | 132); } function isNumericLiteralName(name) { - // The intent of numeric names is that - // - they are names with text in a numeric form, and that - // - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit', - // acquired by applying the abstract 'ToNumber' operation on the name's text. - // - // The subtlety is in the latter portion, as we cannot reliably say that anything that looks like a numeric literal is a numeric name. - // In fact, it is the case that the text of the name must be equal to 'ToString(numLit)' for this to hold. - // - // Consider the property name '"0xF00D"'. When one indexes with '0xF00D', they are actually indexing with the value of 'ToString(0xF00D)' - // according to the ECMAScript specification, so it is actually as if the user indexed with the string '"61453"'. - // Thus, the text of all numeric literals equivalent to '61543' such as '0xF00D', '0xf00D', '0170015', etc. are not valid numeric names - // because their 'ToString' representation is not equal to their original text. - // This is motivated by ECMA-262 sections 9.3.1, 9.8.1, 11.1.5, and 11.2.1. - // - // Here, we test whether 'ToString(ToNumber(name))' is exactly equal to 'name'. - // The '+' prefix operator is equivalent here to applying the abstract ToNumber operation. - // Applying the 'toString()' method on a number gives us the abstract ToString operation on a number. - // - // Note that this accepts the values 'Infinity', '-Infinity', and 'NaN', and that this is intentional. - // This is desired behavior, because when indexing with them as numeric entities, you are indexing - // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively. return (+name).toString() === name; } function checkComputedPropertyName(node) { var links = getNodeLinks(node.expression); if (!links.resolvedType) { links.resolvedType = checkExpression(node.expression); - // This will allow types number, string, symbol or any. It will also allow enums, the unknown - // type, and any union of these types (like string | number). - if (!allConstituentTypesHaveKind(links.resolvedType, 1 /* Any */ | 132 /* NumberLike */ | 258 /* StringLike */ | 1048576 /* ESSymbol */)) { + if (!allConstituentTypesHaveKind(links.resolvedType, 1 | 132 | 258 | 1048576)) { error(node, ts.Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any); } else { @@ -16755,7 +13922,6 @@ var ts; return links.resolvedType; } function checkObjectLiteral(node, contextualMapper) { - // Grammar checking checkGrammarObjectLiteralExpression(node); var propertiesTable = {}; var propertiesArray = []; @@ -16764,22 +13930,22 @@ var ts; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var memberDecl = _a[_i]; var member = memberDecl.symbol; - if (memberDecl.kind === 225 /* PropertyAssignment */ || - memberDecl.kind === 226 /* ShorthandPropertyAssignment */ || + if (memberDecl.kind === 225 || + memberDecl.kind === 226 || ts.isObjectLiteralMethod(memberDecl)) { var type = void 0; - if (memberDecl.kind === 225 /* PropertyAssignment */) { + if (memberDecl.kind === 225) { type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 135 /* MethodDeclaration */) { + else if (memberDecl.kind === 135) { type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 226 /* ShorthandPropertyAssignment */); + ts.Debug.assert(memberDecl.kind === 226); type = checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; - var prop = createSymbol(4 /* Property */ | 67108864 /* Transient */ | member.flags, member.name); + var prop = createSymbol(4 | 67108864 | member.flags, member.name); prop.declarations = member.declarations; prop.parent = member.parent; if (member.valueDeclaration) { @@ -16790,12 +13956,7 @@ var ts; member = prop; } else { - // TypeScript 1.0 spec (April 2014) - // A get accessor declaration is processed in the same manner as - // an ordinary function declaration(section 6.1) with no parameters. - // A set accessor declaration is processed in the same manner - // as an ordinary function declaration with a single parameter and a Void return type. - ts.Debug.assert(memberDecl.kind === 137 /* GetAccessor */ || memberDecl.kind === 138 /* SetAccessor */); + ts.Debug.assert(memberDecl.kind === 137 || memberDecl.kind === 138); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -16803,21 +13964,17 @@ var ts; } propertiesArray.push(member); } - var stringIndexType = getIndexType(0 /* String */); - var numberIndexType = getIndexType(1 /* Number */); + var stringIndexType = getIndexType(0); + var numberIndexType = getIndexType(1); var result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType); - result.flags |= 131072 /* ObjectLiteral */ | 524288 /* ContainsObjectLiteral */ | (typeFlags & 262144 /* ContainsUndefinedOrNull */); + result.flags |= 131072 | 524288 | (typeFlags & 262144); return result; function getIndexType(kind) { if (contextualType && contextualTypeHasIndexSignature(contextualType, kind)) { var propTypes = []; for (var i = 0; i < propertiesArray.length; i++) { var propertyDecl = node.properties[i]; - if (kind === 0 /* String */ || isNumericName(propertyDecl.name)) { - // Do not call getSymbolOfNode(propertyDecl), as that will get the - // original symbol for the node. We actually want to get the symbol - // created by checkObjectLiteral, since that will be appropriately - // contextually typed and resolved. + if (kind === 0 || isNumericName(propertyDecl.name)) { var type = getTypeOfSymbol(propertiesArray[i]); if (!ts.contains(propTypes, type)) { propTypes.push(type); @@ -16831,48 +13988,37 @@ var ts; return undefined; } } - // If a symbol is a synthesized symbol with no value declaration, we assume it is a property. Example of this are the synthesized - // '.prototype' property as well as synthesized tuple index properties. function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 133 /* PropertyDeclaration */; + return s.valueDeclaration ? s.valueDeclaration.kind : 133; } function getDeclarationFlagsFromSymbol(s) { - return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 16 /* Public */ | 128 /* Static */ : 0; + return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0; } function checkClassPropertyAccess(node, left, type, prop) { var flags = getDeclarationFlagsFromSymbol(prop); - // Public properties are always accessible - if (!(flags & (32 /* Private */ | 64 /* Protected */))) { + if (!(flags & (32 | 64))) { return; } - // Property is known to be private or protected at this point - // Get the declaring and enclosing class instance types - var enclosingClassDeclaration = ts.getAncestor(node, 202 /* ClassDeclaration */); + var enclosingClassDeclaration = ts.getAncestor(node, 202); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); - // Private property is accessible if declaring and enclosing class are the same - if (flags & 32 /* Private */) { + if (flags & 32) { if (declaringClass !== enclosingClass) { error(node, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass)); } return; } - // Property is known to be protected at this point - // All protected properties of a supertype are accessible in a super access - if (left.kind === 91 /* SuperKeyword */) { + if (left.kind === 91) { return; } - // A protected property is accessible in the declaring class and classes derived from it if (!enclosingClass || !hasBaseType(enclosingClass, declaringClass)) { error(node, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(declaringClass)); return; } - // No further restrictions for static properties - if (flags & 128 /* Static */) { + if (flags & 128) { return; } - // An instance property must be accessed through an instance of the enclosing class - if (!(getTargetType(type).flags & (1024 /* Class */ | 2048 /* Interface */) && hasBaseType(type, enclosingClass))) { + if (!(getTargetType(type).flags & (1024 | 2048) && hasBaseType(type, enclosingClass))) { error(node, ts.Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass)); } } @@ -16889,7 +14035,6 @@ var ts; if (type !== anyType) { var apparentType = getApparentType(getWidenedType(type)); if (apparentType === unknownType) { - // handle cases when type is Type parameter with invalid constraint return unknownType; } var prop = getPropertyOfType(apparentType, right.text); @@ -16900,15 +14045,8 @@ var ts; return unknownType; } getNodeLinks(node).resolvedSymbol = prop; - if (prop.parent && prop.parent.flags & 32 /* Class */) { - // TS 1.0 spec (April 2014): 4.8.2 - // - In a constructor, instance member function, instance member accessor, or - // instance member variable initializer where this references a derived class instance, - // a super property access is permitted and must specify a public instance member function of the base class. - // - In a static member function or static member accessor - // where this references the constructor function object of a derived class, - // a super property access is permitted and must specify a public static member function of the base class. - if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 135 /* MethodDeclaration */) { + if (prop.parent && prop.parent.flags & 32) { + if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 135) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -16920,14 +14058,14 @@ var ts; return anyType; } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 156 /* PropertyAccessExpression */ + var left = node.kind === 156 ? node.expression : node.left; var type = checkExpressionOrQualifiedName(left); if (type !== unknownType && type !== anyType) { var prop = getPropertyOfType(getWidenedType(type), propertyName); - if (prop && prop.parent && prop.parent.flags & 32 /* Class */) { - if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 135 /* MethodDeclaration */) { + if (prop && prop.parent && prop.parent.flags & 32) { + if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 135) { return false; } else { @@ -16940,10 +14078,9 @@ var ts; return true; } function checkIndexedAccess(node) { - // Grammar checking if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 159 /* NewExpression */ && node.parent.expression === node) { + if (node.parent.kind === 159 && node.parent.expression === node) { var start = ts.skipTrivia(sourceFile.text, node.expression.end); var end = node.end; grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead); @@ -16954,7 +14091,6 @@ var ts; grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Expression_expected); } } - // Obtain base constraint such that we can bail out if the constraint is an unknown type var objectType = getApparentType(checkExpression(node.expression)); var indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType; if (objectType === unknownType) { @@ -16962,19 +14098,10 @@ var ts; } var isConstEnum = isConstEnumObjectType(objectType); if (isConstEnum && - (!node.argumentExpression || node.argumentExpression.kind !== 8 /* StringLiteral */)) { + (!node.argumentExpression || node.argumentExpression.kind !== 8)) { error(node.argumentExpression, ts.Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal); return unknownType; } - // TypeScript 1.0 spec (April 2014): 4.10 Property Access - // - If IndexExpr is a string literal or a numeric literal and ObjExpr's apparent type has a property with the name - // given by that literal(converted to its string representation in the case of a numeric literal), the property access is of the type of that property. - // - Otherwise, if ObjExpr's apparent type has a numeric index signature and IndexExpr is of type Any, the Number primitive type, or an enum type, - // the property access is of the type of that index signature. - // - Otherwise, if ObjExpr's apparent type has a string index signature and IndexExpr is of type Any, the String or Number primitive type, or an enum type, - // the property access is of the type of that index signature. - // - Otherwise, if IndexExpr is of type Any, the String or Number primitive type, or an enum type, the property access is of type Any. - // See if we can index as a property. if (node.argumentExpression) { var name_6 = getPropertyNameForIndexedAccess(node.argumentExpression, indexType); if (name_6 !== undefined) { @@ -16989,38 +14116,27 @@ var ts; } } } - // Check for compatible indexer types. - if (allConstituentTypesHaveKind(indexType, 1 /* Any */ | 258 /* StringLike */ | 132 /* NumberLike */ | 1048576 /* ESSymbol */)) { - // Try to use a number indexer. - if (allConstituentTypesHaveKind(indexType, 1 /* Any */ | 132 /* NumberLike */)) { - var numberIndexType = getIndexTypeOfType(objectType, 1 /* Number */); + if (allConstituentTypesHaveKind(indexType, 1 | 258 | 132 | 1048576)) { + if (allConstituentTypesHaveKind(indexType, 1 | 132)) { + var numberIndexType = getIndexTypeOfType(objectType, 1); if (numberIndexType) { return numberIndexType; } } - // Try to use string indexing. - var stringIndexType = getIndexTypeOfType(objectType, 0 /* String */); + var stringIndexType = getIndexTypeOfType(objectType, 0); if (stringIndexType) { return stringIndexType; } - // Fall back to any. if (compilerOptions.noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && objectType !== anyType) { error(node, ts.Diagnostics.Index_signature_of_object_type_implicitly_has_an_any_type); } return anyType; } - // REVIEW: Users should know the type that was actually used. error(node, ts.Diagnostics.An_index_expression_argument_must_be_of_type_string_number_symbol_or_any); return unknownType; } - /** - * If indexArgumentExpression is a string literal or number literal, returns its text. - * If indexArgumentExpression is a well known symbol, returns the property name corresponding - * to this symbol, as long as it is a proper symbol reference. - * Otherwise, returns undefined. - */ function getPropertyNameForIndexedAccess(indexArgumentExpression, indexArgumentType) { - if (indexArgumentExpression.kind === 8 /* StringLiteral */ || indexArgumentExpression.kind === 7 /* NumericLiteral */) { + if (indexArgumentExpression.kind === 8 || indexArgumentExpression.kind === 7) { return indexArgumentExpression.text; } if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, false)) { @@ -17029,30 +14145,19 @@ var ts; } return undefined; } - /** - * A proper symbol reference requires the following: - * 1. The property access denotes a property that exists - * 2. The expression is of the form Symbol. - * 3. The property access is of the primitive type symbol. - * 4. Symbol in this context resolves to the global Symbol object - */ function checkThatExpressionIsProperSymbolReference(expression, expressionType, reportError) { if (expressionType === unknownType) { - // There is already an error, so no need to report one. return false; } if (!ts.isWellKnownSymbolSyntactically(expression)) { return false; } - // Make sure the property type is the primitive symbol type - if ((expressionType.flags & 1048576 /* ESSymbol */) === 0) { + if ((expressionType.flags & 1048576) === 0) { if (reportError) { error(expression, ts.Diagnostics.A_computed_property_name_of_the_form_0_must_be_of_type_symbol, ts.getTextOfNode(expression)); } return false; } - // The name is Symbol., so make sure Symbol actually resolves to the - // global Symbol object var leftHandSide = expression.expression; var leftHandSideSymbol = getResolvedSymbol(leftHandSide); if (!leftHandSideSymbol) { @@ -17060,7 +14165,6 @@ var ts; } var globalESSymbol = getGlobalESSymbolConstructorSymbol(); if (!globalESSymbol) { - // Already errored when we tried to look up the symbol return false; } if (leftHandSideSymbol !== globalESSymbol) { @@ -17072,7 +14176,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 160) { checkExpression(node.template); } else { @@ -17086,14 +14190,6 @@ var ts; resolveUntypedCall(node); return unknownSignature; } - // Re-order candidate signatures into the result array. Assumes the result array to be empty. - // The candidate list orders groups in reverse, but within a group signatures are kept in declaration order - // A nit here is that we reorder only signatures that belong to the same symbol, - // so order how inherited signatures are processed is still preserved. - // interface A { (x: string): void } - // interface B extends A { (x: 'foo'): string } - // let b: B; - // b('foo') // <- here overloads should be processed as [(x:'foo'): string, (x: string): void] function reorderCandidates(signatures, result) { var lastParent; var lastSymbol; @@ -17116,20 +14212,13 @@ var ts; } } else { - // current declaration belongs to a different symbol - // set cutoffIndex so re-orderings in the future won't change result set from 0 to cutoffIndex index = cutoffIndex = result.length; lastParent = parent_4; } lastSymbol = symbol; - // specialized signatures always need to be placed before non-specialized signatures regardless - // of the cutoff position; see GH#1133 if (signature.hasStringLiterals) { specializedIndex++; spliceIndex = specializedIndex; - // The cutoff index always needs to be greater than or equal to the specialized signature index - // in order to prevent non-specialized signatures from being added before a specialized - // signature. cutoffIndex++; } else { @@ -17140,76 +14229,59 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 174 /* SpreadElementExpression */) { + if (args[i].kind === 174) { return i; } } return -1; } function hasCorrectArity(node, args, signature) { - var adjustedArgCount; // Apparent number of arguments we will have in this call - var typeArguments; // Type arguments (undefined if none) - var callIsIncomplete; // In incomplete call we want to be lenient when we have too few arguments - if (node.kind === 160 /* TaggedTemplateExpression */) { + var adjustedArgCount; + var typeArguments; + var callIsIncomplete; + if (node.kind === 160) { var tagExpression = node; - // Even if the call is incomplete, we'll have a missing expression as our last argument, - // so we can say the count is just the arg list length adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 172 /* TemplateExpression */) { - // If a tagged template expression lacks a tail literal, the call is incomplete. - // Specifically, a template only can end in a TemplateTail or a Missing literal. + if (tagExpression.template.kind === 172) { var templateExpression = tagExpression.template; var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans); - ts.Debug.assert(lastSpan !== undefined); // we should always have at least one span. + ts.Debug.assert(lastSpan !== undefined); callIsIncomplete = ts.nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated; } else { - // If the template didn't end in a backtick, or its beginning occurred right prior to EOF, - // then this might actually turn out to be a TemplateHead in the future; - // so we consider the call to be incomplete. var templateLiteral = tagExpression.template; - ts.Debug.assert(templateLiteral.kind === 10 /* NoSubstitutionTemplateLiteral */); + ts.Debug.assert(templateLiteral.kind === 10); callIsIncomplete = !!templateLiteral.isUnterminated; } } else { var callExpression = node; if (!callExpression.arguments) { - // This only happens when we have something of the form: 'new C' - ts.Debug.assert(callExpression.kind === 159 /* NewExpression */); + ts.Debug.assert(callExpression.kind === 159); return signature.minArgumentCount === 0; } - // For IDE scenarios we may have an incomplete call, so a trailing comma is tantamount to adding another argument. adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; - // If we are missing the close paren, the call is incomplete. callIsIncomplete = callExpression.arguments.end === callExpression.end; typeArguments = callExpression.typeArguments; } - // If the user supplied type arguments, but the number of type arguments does not match - // the declared number of type parameters, the call has an incorrect arity. var hasRightNumberOfTypeArgs = !typeArguments || (signature.typeParameters && typeArguments.length === signature.typeParameters.length); if (!hasRightNumberOfTypeArgs) { return false; } - // If spread arguments are present, check that they correspond to a rest parameter. If so, no - // further checking is necessary. var spreadArgIndex = getSpreadArgumentIndex(args); if (spreadArgIndex >= 0) { return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1; } - // Too many arguments implies incorrect arity. if (!signature.hasRestParameter && adjustedArgCount > signature.parameters.length) { return false; } - // If the call is incomplete, we should skip the lower bound check. var hasEnoughArguments = adjustedArgCount >= signature.minArgumentCount; return callIsIncomplete || hasEnoughArguments; } - // If type has a single call signature and no other members, return that signature. Otherwise, return undefined. function getSingleCallSignature(type) { - if (type.flags & 48128 /* ObjectType */) { + if (type.flags & 48128) { var resolved = resolveObjectOrUnionTypeMembers(type); if (resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0 && resolved.properties.length === 0 && !resolved.stringIndexType && !resolved.numberIndexType) { @@ -17218,11 +14290,9 @@ var ts; } return undefined; } - // Instantiate a generic signature in the context of a non-generic signature (section 3.8.5 in TypeScript spec) function instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper) { var context = createInferenceContext(signature.typeParameters, true); forEachMatchingParameterType(contextualSignature, signature, function (source, target) { - // Type parameters from outer context referenced by source type are fixed by instantiation of the source type inferTypes(context, instantiateType(source, contextualMapper), target); }); return getSignatureInstantiation(signature, getInferredTypes(context)); @@ -17230,51 +14300,31 @@ var ts; function inferTypeArguments(signature, args, excludeArgument, context) { var typeParameters = signature.typeParameters; var inferenceMapper = createInferenceMapper(context); - // Clear out all the inference results from the last time inferTypeArguments was called on this context for (var i = 0; i < typeParameters.length; i++) { - // As an optimization, we don't have to clear (and later recompute) inferred types - // for type parameters that have already been fixed on the previous call to inferTypeArguments. - // It would be just as correct to reset all of them. But then we'd be repeating the same work - // for the type parameters that were fixed, namely the work done by getInferredType. if (!context.inferences[i].isFixed) { context.inferredTypes[i] = undefined; } } - // On this call to inferTypeArguments, we may get more inferences for certain type parameters that were not - // fixed last time. This means that a type parameter that failed inference last time may succeed this time, - // or vice versa. Therefore, the failedTypeParameterIndex is useless if it points to an unfixed type parameter, - // because it may change. So here we reset it. However, getInferredType will not revisit any type parameters - // that were previously fixed. So if a fixed type parameter failed previously, it will fail again because - // it will contain the exact same set of inferences. So if we reset the index from a fixed type parameter, - // we will lose information that we won't recover this time around. if (context.failedTypeParameterIndex !== undefined && !context.inferences[context.failedTypeParameterIndex].isFixed) { context.failedTypeParameterIndex = undefined; } - // We perform two passes over the arguments. In the first pass we infer from all arguments, but use - // wildcards for all context sensitive function expressions. for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176 /* OmittedExpression */) { + if (arg.kind !== 176) { var paramType = getTypeAtPosition(signature, i); var argType = void 0; - if (i === 0 && args[i].parent.kind === 160 /* TaggedTemplateExpression */) { + if (i === 0 && args[i].parent.kind === 160) { argType = globalTemplateStringsArrayType; } else { - // For context sensitive arguments we pass the identityMapper, which is a signal to treat all - // context sensitive function expressions as wildcards var mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; argType = checkExpressionWithContextualType(arg, paramType, mapper); } inferTypes(context, argType, paramType); } } - // In the second pass we visit only context sensitive arguments, and only those that aren't excluded, this - // time treating function expressions normally (which may cause previously inferred type arguments to be fixed - // as we construct types for contextually typed parameters) if (excludeArgument) { for (var i = 0; i < args.length; i++) { - // No need to check for omitted args and template expressions, their exlusion value is always undefined if (excludeArgument[i] === false) { var arg = args[i]; var paramType = getTypeAtPosition(signature, i); @@ -17290,9 +14340,8 @@ var ts; for (var i = 0; i < typeParameters.length; i++) { var typeArgNode = typeArguments[i]; var typeArgument = getTypeFromTypeNode(typeArgNode); - // Do not push on this array! It has a preallocated length typeArgumentResultTypes[i] = typeArgument; - if (typeArgumentsAreAssignable /* so far */) { + if (typeArgumentsAreAssignable) { var constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); @@ -17304,17 +14353,13 @@ var ts; function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176 /* OmittedExpression */) { - // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) + if (arg.kind !== 176) { var paramType = getTypeAtPosition(signature, i); - // A tagged template expression provides a special first argument, and string literals get string literal types - // unless we're reporting errors - var argType = i === 0 && node.kind === 160 /* TaggedTemplateExpression */ + var argType = i === 0 && node.kind === 160 ? globalTemplateStringsArrayType - : arg.kind === 8 /* StringLiteral */ && !reportErrors + : arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); - // Use argument expression as error location when reporting errors if (!checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1)) { return false; } @@ -17322,19 +14367,12 @@ var ts; } return true; } - /** - * Returns the effective arguments for an expression that works like a function invocation. - * - * If 'node' is a CallExpression or a NewExpression, then its argument list is returned. - * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution - * expressions, where the first element of the list is the template for error reporting purposes. - */ function getEffectiveCallArguments(node) { var args; - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 160) { var template = node.template; args = [template]; - if (template.kind === 172 /* TemplateExpression */) { + if (template.kind === 172) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -17345,56 +14383,32 @@ var ts; } return args; } - /** - * In a 'super' call, type arguments are not provided within the CallExpression node itself. - * Instead, they must be fetched from the class declaration's base type node. - * - * If 'node' is a 'super' call (e.g. super(...), new super(...)), then we attempt to fetch - * the type arguments off the containing class's first heritage clause (if one exists). Note that if - * type arguments are supplied on the 'super' call, they are ignored (though this is syntactically incorrect). - * - * In all other cases, the call's explicit type arguments are returned. - */ function getEffectiveTypeArguments(callExpression) { - if (callExpression.expression.kind === 91 /* SuperKeyword */) { - var containingClass = ts.getAncestor(callExpression, 202 /* ClassDeclaration */); + if (callExpression.expression.kind === 91) { + var containingClass = ts.getAncestor(callExpression, 202); var baseClassTypeNode = containingClass && ts.getClassExtendsHeritageClauseElement(containingClass); return baseClassTypeNode && baseClassTypeNode.typeArguments; } else { - // Ordinary case - simple function invocation. return callExpression.typeArguments; } } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 160 /* TaggedTemplateExpression */; + var isTaggedTemplate = node.kind === 160; var typeArguments; if (!isTaggedTemplate) { typeArguments = getEffectiveTypeArguments(node); - // We already perform checking on the type arguments on the class declaration itself. - if (node.expression.kind !== 91 /* SuperKeyword */) { + if (node.expression.kind !== 91) { ts.forEach(typeArguments, checkSourceElement); } } var candidates = candidatesOutArray || []; - // reorderCandidates fills up the candidates array directly reorderCandidates(signatures, candidates); if (!candidates.length) { error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); return resolveErrorCall(node); } var args = getEffectiveCallArguments(node); - // The following applies to any value of 'excludeArgument[i]': - // - true: the argument at 'i' is susceptible to a one-time permanent contextual typing. - // - undefined: the argument at 'i' is *not* susceptible to permanent contextual typing. - // - false: the argument at 'i' *was* and *has been* permanently contextually typed. - // - // The idea is that we will perform type argument inference & assignability checking once - // without using the susceptible parameters that are functions, and once more for each of those - // parameters, contextually typing each as we go along. - // - // For a tagged template, then the first argument be 'undefined' if necessary - // because it represents a TemplateStringsArray. var excludeArgument; for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { if (isContextSensitive(args[i])) { @@ -17404,46 +14418,14 @@ var ts; excludeArgument[i] = true; } } - // The following variables are captured and modified by calls to chooseOverload. - // If overload resolution or type argument inference fails, we want to report the - // best error possible. The best error is one which says that an argument was not - // assignable to a parameter. This implies that everything else about the overload - // was fine. So if there is any overload that is only incorrect because of an - // argument, we will report an error on that one. - // - // function foo(s: string) {} - // function foo(n: number) {} // Report argument error on this overload - // function foo() {} - // foo(true); - // - // If none of the overloads even made it that far, there are two possibilities. - // There was a problem with type arguments for some overload, in which case - // report an error on that. Or none of the overloads even had correct arity, - // in which case give an arity error. - // - // function foo(x: T, y: T) {} // Report type argument inference error - // function foo() {} - // foo(0, true); - // var candidateForArgumentError; var candidateForTypeArgumentError; var resultOfFailedInference; var result; - // Section 4.12.1: - // if the candidate list contains one or more signatures for which the type of each argument - // expression is a subtype of each corresponding parameter type, the return type of the first - // of those signatures becomes the return type of the function call. - // Otherwise, the return type of the first signature in the candidate list becomes the return - // type of the function call. - // - // Whether the call is an error is determined by assignability of the arguments. The subtype pass - // is just important for choosing the best signature. So in the case where there is only one - // signature, the subtype pass is useless. So skipping it is an optimization. if (candidates.length > 1) { result = chooseOverload(candidates, subtypeRelation); } if (!result) { - // Reinitialize these pointers for round two candidateForArgumentError = undefined; candidateForTypeArgumentError = undefined; resultOfFailedInference = undefined; @@ -17452,16 +14434,7 @@ var ts; if (result) { return result; } - // No signatures were applicable. Now report errors based on the last applicable signature with - // no arguments excluded from assignability checks. - // If candidate is undefined, it means that no candidates had a suitable arity. In that case, - // skip the checkApplicableSignature check. if (candidateForArgumentError) { - // excludeArgument is undefined, in this case also equivalent to [undefined, undefined, ...] - // The importance of excludeArgument is to prevent us from typing function expression parameters - // in arguments too early. If possible, we'd like to only type them once we know the correct - // overload. However, this matters for the case where the call is correct. When the call is - // an error, we don't need to exclude any arguments, although it would cause no harm to do so. checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { @@ -17479,11 +14452,6 @@ var ts; else { error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); } - // No signature was applicable. We have already reported the errors for the invalid signature. - // If this is a type resolution session, e.g. Language Service, try to get better information that anySignature. - // Pick the first candidate that matches the arity. This way we can get a contextual type for cases like: - // declare function f(a: { xa: number; xb: number; }); - // f({ | if (!produceDiagnostics) { for (var _i = 0; _i < candidates.length; _i++) { var candidate = candidates[_i]; @@ -17531,11 +14499,6 @@ var ts; } excludeArgument[index] = false; } - // A post-mortem of this iteration of the loop. The signature was not applicable, - // so we want to track it as a candidate for reporting an error. If the candidate - // had no type parameters, or had no issues related to type arguments, we can - // report an error based on the arguments. If there was an issue with type - // arguments, then we can only report an error based on the type arguments. if (originalCandidate.typeParameters) { var instantiatedCandidate = candidate; if (typeArgumentsAreValid) { @@ -17557,41 +14520,26 @@ var ts; } } function resolveCallExpression(node, candidatesOutArray) { - if (node.expression.kind === 91 /* SuperKeyword */) { + if (node.expression.kind === 91) { var superType = checkSuperExpression(node.expression); if (superType !== unknownType) { - return resolveCall(node, getSignaturesOfType(superType, 1 /* Construct */), candidatesOutArray); + return resolveCall(node, getSignaturesOfType(superType, 1), candidatesOutArray); } return resolveUntypedCall(node); } var funcType = checkExpression(node.expression); var apparentType = getApparentType(funcType); if (apparentType === unknownType) { - // Another error has already been reported return resolveErrorCall(node); } - // Technically, this signatures list may be incomplete. We are taking the apparent type, - // but we are not including call signatures that may have been added to the Object or - // Function interface, since they have none by default. This is a bit of a leap of faith - // that the user will not add any. - var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */); - var constructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */); - // TS 1.0 spec: 4.12 - // If FuncExpr is of type Any, or of an object type that has no call or construct signatures - // but is a subtype of the Function interface, the call is an untyped function call. In an - // untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual - // types are provided for the argument expressions, and the result is always of type Any. - // We exclude union types because we may have a union of function types that happen to have - // no common signatures. - if (funcType === anyType || (!callSignatures.length && !constructSignatures.length && !(funcType.flags & 16384 /* Union */) && isTypeAssignableTo(funcType, globalFunctionType))) { + var callSignatures = getSignaturesOfType(apparentType, 0); + var constructSignatures = getSignaturesOfType(apparentType, 1); + if (funcType === anyType || (!callSignatures.length && !constructSignatures.length && !(funcType.flags & 16384) && isTypeAssignableTo(funcType, globalFunctionType))) { if (node.typeArguments) { error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); } return resolveUntypedCall(node); } - // If FuncExpr's apparent type(section 3.8.1) is a function type, the call is a typed function call. - // TypeScript employs overload resolution in typed function calls in order to support functions - // with multiple call signatures. if (!callSignatures.length) { if (constructSignatures.length) { error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType)); @@ -17604,45 +14552,28 @@ var ts; return resolveCall(node, callSignatures, candidatesOutArray); } function resolveNewExpression(node, candidatesOutArray) { - if (node.arguments && languageVersion < 2 /* ES6 */) { + if (node.arguments && languageVersion < 2) { var spreadIndex = getSpreadArgumentIndex(node.arguments); if (spreadIndex >= 0) { error(node.arguments[spreadIndex], ts.Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_6_and_higher); } } var expressionType = checkExpression(node.expression); - // TS 1.0 spec: 4.11 - // If ConstructExpr is of type Any, Args can be any argument - // list and the result of the operation is of type Any. if (expressionType === anyType) { if (node.typeArguments) { error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); } return resolveUntypedCall(node); } - // If ConstructExpr's apparent type(section 3.8.1) is an object type with one or - // more construct signatures, the expression is processed in the same manner as a - // function call, but using the construct signatures as the initial set of candidate - // signatures for overload resolution.The result type of the function call becomes - // the result type of the operation. expressionType = getApparentType(expressionType); if (expressionType === unknownType) { - // Another error has already been reported return resolveErrorCall(node); } - // Technically, this signatures list may be incomplete. We are taking the apparent type, - // but we are not including construct signatures that may have been added to the Object or - // Function interface, since they have none by default. This is a bit of a leap of faith - // that the user will not add any. - var constructSignatures = getSignaturesOfType(expressionType, 1 /* Construct */); + var constructSignatures = getSignaturesOfType(expressionType, 1); if (constructSignatures.length) { return resolveCall(node, constructSignatures, candidatesOutArray); } - // If ConstructExpr's apparent type is an object type with no construct signatures but - // one or more call signatures, the expression is processed as a function call. A compile-time - // error occurs if the result of the function call is not Void. The type of the result of the - // operation is Any. - var callSignatures = getSignaturesOfType(expressionType, 0 /* Call */); + var callSignatures = getSignaturesOfType(expressionType, 0); if (callSignatures.length) { var signature = resolveCall(node, callSignatures, candidatesOutArray); if (getReturnTypeOfSignature(signature) !== voidType) { @@ -17657,11 +14588,10 @@ var ts; var tagType = checkExpression(node.tag); var apparentType = getApparentType(tagType); if (apparentType === unknownType) { - // Another error has already been reported return resolveErrorCall(node); } - var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */); - if (tagType === anyType || (!callSignatures.length && !(tagType.flags & 16384 /* Union */) && isTypeAssignableTo(tagType, globalFunctionType))) { + var callSignatures = getSignaturesOfType(apparentType, 0); + if (tagType === anyType || (!callSignatures.length && !(tagType.flags & 16384) && isTypeAssignableTo(tagType, globalFunctionType))) { return resolveUntypedCall(node); } if (!callSignatures.length) { @@ -17670,23 +14600,17 @@ var ts; } return resolveCall(node, callSignatures, candidatesOutArray); } - // candidatesOutArray is passed by signature help in the language service, and collectCandidates - // must fill it up with the appropriate candidate signatures function getResolvedSignature(node, candidatesOutArray) { var links = getNodeLinks(node); - // If getResolvedSignature has already been called, we will have cached the resolvedSignature. - // However, it is possible that either candidatesOutArray was not passed in the first time, - // or that a different candidatesOutArray was passed in. Therefore, we need to redo the work - // to correctly fill the candidatesOutArray. if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 158 /* CallExpression */) { + if (node.kind === 158) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 159 /* NewExpression */) { + else if (node.kind === 159) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 160) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -17696,19 +14620,17 @@ var ts; return links.resolvedSignature; } function checkCallExpression(node) { - // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments); var signature = getResolvedSignature(node); - if (node.expression.kind === 91 /* SuperKeyword */) { + if (node.expression.kind === 91) { return voidType; } - if (node.kind === 159 /* NewExpression */) { + if (node.kind === 159) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 136 /* Constructor */ && - declaration.kind !== 140 /* ConstructSignature */ && - declaration.kind !== 144 /* ConstructorType */) { - // When resolved signature is a call signature (and not a construct signature) the result type is any + declaration.kind !== 136 && + declaration.kind !== 140 && + declaration.kind !== 144) { if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); } @@ -17744,9 +14666,9 @@ var ts; links.type = instantiateType(getTypeAtPosition(context, i), mapper); } if (signature.hasRestParameter && context.hasRestParameter && signature.parameters.length >= context.parameters.length) { - var parameter = signature.parameters[signature.parameters.length - 1]; + var parameter = ts.lastOrUndefined(signature.parameters); var links = getSymbolLinks(parameter); - links.type = instantiateType(getTypeOfSymbol(context.parameters[context.parameters.length - 1]), mapper); + links.type = instantiateType(getTypeOfSymbol(ts.lastOrUndefined(context.parameters)), mapper); } } function getReturnTypeFromBody(func, contextualMapper) { @@ -17755,17 +14677,14 @@ var ts; return unknownType; } var type; - if (func.body.kind !== 180 /* Block */) { + if (func.body.kind !== 180) { type = checkExpressionCached(func.body, contextualMapper); } else { - // Aggregate the types of expressions within all the return statements. var types = checkAndAggregateReturnExpressionTypes(func.body, contextualMapper); if (types.length === 0) { return voidType; } - // When return statements are contextually typed we allow the return type to be a union type. Otherwise we require the - // return expressions to have a best common supertype. type = contextualSignature ? getUnionType(types) : getCommonSupertype(types); if (!type) { error(func, ts.Diagnostics.No_best_common_type_exists_among_return_expressions); @@ -17777,7 +14696,6 @@ var ts; } return getWidenedType(type); } - /// Returns a set of types relating to every return expression relating to a function block. function checkAndAggregateReturnExpressionTypes(body, contextualMapper) { var aggregatedTypes = []; ts.forEachReturnStatement(body, function (returnStatement) { @@ -17797,61 +14715,44 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 196 /* ThrowStatement */); + return (body.statements.length === 1) && (body.statements[0].kind === 196); } - // TypeScript Specification 1.0 (6.3) - July 2014 - // An explicitly typed function whose return type isn't the Void or the Any type - // must have at least one return statement somewhere in its body. - // An exception to this rule is if the function implementation consists of a single 'throw' statement. function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) { if (!produceDiagnostics) { return; } - // Functions that return 'void' or 'any' don't need any return expressions. if (returnType === voidType || returnType === anyType) { return; } - // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check. - if (ts.nodeIsMissing(func.body) || func.body.kind !== 180 /* Block */) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 180) { return; } var bodyBlock = func.body; - // Ensure the body has at least one return expression. if (bodyContainsAReturnStatement(bodyBlock)) { return; } - // If there are no return expressions, then we need to check if - // the function body consists solely of a throw statement; - // this is to make an exception for unimplemented functions. if (bodyContainsSingleThrowStatement(bodyBlock)) { return; } - // This function does not conform to the specification. error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement); } function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); - // Grammar checking + ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); var hasGrammarError = checkGrammarDeclarationNameInStrictMode(node) || checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 163 /* FunctionExpression */) { + if (!hasGrammarError && node.kind === 163) { checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); } - // The identityMapper object is used to indicate that function expressions are wildcards if (contextualMapper === identityMapper && isContextSensitive(node)) { return anyFunctionType; } var links = getNodeLinks(node); var type = getTypeOfSymbol(node.symbol); - // Check if function expression is contextually typed and assign parameter types if so - if (!(links.flags & 64 /* ContextChecked */)) { + if (!(links.flags & 64)) { var contextualSignature = getContextualSignature(node); - // If a type check is started at a function expression that is an argument of a function call, obtaining the - // contextual type may recursively get back to here during overload resolution of the call. If so, we will have - // already assigned contextual types. - if (!(links.flags & 64 /* ContextChecked */)) { - links.flags |= 64 /* ContextChecked */; + if (!(links.flags & 64)) { + links.flags |= 64; if (contextualSignature) { - var signature = getSignaturesOfType(type, 0 /* Call */)[0]; + var signature = getSignaturesOfType(type, 0)[0]; if (isContextSensitive(node)) { assignContextualParameterTypes(signature, contextualSignature, contextualMapper || identityMapper); } @@ -17866,19 +14767,19 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (produceDiagnostics && node.kind !== 135 && node.kind !== 134) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); if (node.type && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } if (node.body) { - if (node.body.kind === 180 /* Block */) { + if (node.body.kind === 180) { checkSourceElement(node.body); } else { @@ -17891,7 +14792,7 @@ var ts; } } function checkArithmeticOperandType(operand, type, diagnostic) { - if (!allConstituentTypesHaveKind(type, 1 /* Any */ | 132 /* NumberLike */)) { + if (!allConstituentTypesHaveKind(type, 1 | 132)) { error(operand, diagnostic); return false; } @@ -17900,37 +14801,21 @@ var ts; function checkReferenceExpression(n, invalidReferenceMessage, constantVariableMessage) { function findSymbol(n) { var symbol = getNodeLinks(n).resolvedSymbol; - // Because we got the symbol from the resolvedSymbol property, it might be of kind - // SymbolFlags.ExportValue. In this case it is necessary to get the actual export - // symbol, which will have the correct flags set on it. return symbol && getExportSymbolOfValueSymbolIfExported(symbol); } function isReferenceOrErrorExpression(n) { - // TypeScript 1.0 spec (April 2014): - // Expressions are classified as values or references. - // References are the subset of expressions that are permitted as the target of an assignment. - // Specifically, references are combinations of identifiers(section 4.3), parentheses(section 4.7), - // and property accesses(section 4.10). - // All other expression constructs described in this chapter are classified as values. switch (n.kind) { - case 65 /* Identifier */: { + case 65: { var symbol = findSymbol(n); - // TypeScript 1.0 spec (April 2014): 4.3 - // An identifier expression that references a variable or parameter is classified as a reference. - // An identifier expression that references any other kind of entity is classified as a value(and therefore cannot be the target of an assignment). - return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3 /* Variable */) !== 0; + return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3) !== 0; } - case 156 /* PropertyAccessExpression */: { + case 156: { var symbol = findSymbol(n); - // TypeScript 1.0 spec (April 2014): 4.10 - // A property access expression is always classified as a reference. - // NOTE (not in spec): assignment to enum members should not be allowed - return !symbol || symbol === unknownSymbol || (symbol.flags & ~8 /* EnumMember */) !== 0; + return !symbol || symbol === unknownSymbol || (symbol.flags & ~8) !== 0; } - case 157 /* ElementAccessExpression */: - // old compiler doesn't check indexed assess + case 157: return true; - case 162 /* ParenthesizedExpression */: + case 162: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -17938,22 +14823,22 @@ var ts; } function isConstVariableReference(n) { switch (n.kind) { - case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: { + case 65: + case 156: { var symbol = findSymbol(n); - return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 8192 /* Const */) !== 0; + return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 8192) !== 0; } - case 157 /* ElementAccessExpression */: { + case 157: { var index = n.argumentExpression; var symbol = findSymbol(n.expression); - if (symbol && index && index.kind === 8 /* StringLiteral */) { + if (symbol && index && index.kind === 8) { var name_7 = index.text; var prop = getPropertyOfType(getTypeOfSymbol(symbol), name_7); - return prop && (prop.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 8192 /* Const */) !== 0; + return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 8192) !== 0; } return false; } - case 162 /* ParenthesizedExpression */: + case 162: return isConstVariableReference(n.expression); default: return false; @@ -17970,10 +14855,7 @@ var ts; return true; } function checkDeleteExpression(node) { - // Grammar checking - if (node.parserContextFlags & 1 /* StrictMode */ && node.expression.kind === 65 /* Identifier */) { - // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its - // UnaryExpression is a direct reference to a variable, function argument, or function name + if (node.parserContextFlags & 1 && node.expression.kind === 65) { grammarErrorOnNode(node.expression, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode); } var operandType = checkExpression(node.expression); @@ -17988,29 +14870,24 @@ var ts; return undefinedType; } function checkPrefixUnaryExpression(node) { - // Grammar checking - // The identifier eval or arguments may not appear as the LeftHandSideExpression of an - // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression - // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator - if ((node.operator === 38 /* PlusPlusToken */ || node.operator === 39 /* MinusMinusToken */)) { + if ((node.operator === 38 || node.operator === 39)) { checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); } var operandType = checkExpression(node.operand); switch (node.operator) { - case 33 /* PlusToken */: - case 34 /* MinusToken */: - case 47 /* TildeToken */: - if (someConstituentTypeHasKind(operandType, 1048576 /* ESSymbol */)) { + case 33: + case 34: + case 47: + if (someConstituentTypeHasKind(operandType, 1048576)) { error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator)); } return numberType; - case 46 /* ExclamationToken */: + case 46: return booleanType; - case 38 /* PlusPlusToken */: - case 39 /* MinusMinusToken */: + case 38: + case 39: var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type); if (ok) { - // run check only if former checks succeeded to avoid reporting cascading errors checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant); } return numberType; @@ -18018,26 +14895,19 @@ var ts; return unknownType; } function checkPostfixUnaryExpression(node) { - // Grammar checking - // The identifier eval or arguments may not appear as the LeftHandSideExpression of an - // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression - // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator. checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); var operandType = checkExpression(node.operand); var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type); if (ok) { - // run check only if former checks succeeded to avoid reporting cascading errors checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant); } return numberType; } - // Just like isTypeOfKind below, except that it returns true if *any* constituent - // has this kind. function someConstituentTypeHasKind(type, kind) { if (type.flags & kind) { return true; } - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { var types = type.types; for (var _i = 0; _i < types.length; _i++) { var current = types[_i]; @@ -18049,12 +14919,11 @@ var ts; } return false; } - // Return true if type has the given flags, or is a union type composed of types that all have those flags. function allConstituentTypesHaveKind(type, kind) { if (type.flags & kind) { return true; } - if (type.flags & 16384 /* Union */) { + if (type.flags & 16384) { var types = type.types; for (var _i = 0; _i < types.length; _i++) { var current = types[_i]; @@ -18067,35 +14936,25 @@ var ts; return false; } function isConstEnumObjectType(type) { - return type.flags & (48128 /* ObjectType */ | 32768 /* Anonymous */) && type.symbol && isConstEnumSymbol(type.symbol); + return type.flags & (48128 | 32768) && type.symbol && isConstEnumSymbol(type.symbol); } function isConstEnumSymbol(symbol) { - return (symbol.flags & 128 /* ConstEnum */) !== 0; + return (symbol.flags & 128) !== 0; } function checkInstanceOfExpression(node, leftType, rightType) { - // TypeScript 1.0 spec (April 2014): 4.15.4 - // The instanceof operator requires the left operand to be of type Any, an object type, or a type parameter type, - // and the right operand to be of type Any or a subtype of the 'Function' interface type. - // The result is always of the Boolean primitive type. - // NOTE: do not raise error if leftType is unknown as related error was already reported - if (allConstituentTypesHaveKind(leftType, 1049086 /* Primitive */)) { + if (allConstituentTypesHaveKind(leftType, 1049086)) { error(node.left, ts.Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); } - // NOTE: do not raise error if right is unknown as related error was already reported - if (!(rightType.flags & 1 /* Any */ || isTypeSubtypeOf(rightType, globalFunctionType))) { + if (!(rightType.flags & 1 || isTypeSubtypeOf(rightType, globalFunctionType))) { error(node.right, ts.Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type); } return booleanType; } function checkInExpression(node, leftType, rightType) { - // TypeScript 1.0 spec (April 2014): 4.15.5 - // The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type, - // and the right operand to be of type Any, an object type, or a type parameter type. - // The result is always of the Boolean primitive type. - if (!allConstituentTypesHaveKind(leftType, 1 /* Any */ | 258 /* StringLike */ | 132 /* NumberLike */ | 1048576 /* ESSymbol */)) { + if (!allConstituentTypesHaveKind(leftType, 1 | 258 | 132 | 1048576)) { error(node.left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); } - if (!allConstituentTypesHaveKind(rightType, 1 /* Any */ | 48128 /* ObjectType */ | 512 /* TypeParameter */)) { + if (!allConstituentTypesHaveKind(rightType, 1 | 48128 | 512)) { error(node.right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); } return booleanType; @@ -18104,13 +14963,12 @@ var ts; var properties = node.properties; for (var _i = 0; _i < properties.length; _i++) { var p = properties[_i]; - if (p.kind === 225 /* PropertyAssignment */ || p.kind === 226 /* ShorthandPropertyAssignment */) { - // TODO(andersh): Computed property support + if (p.kind === 225 || p.kind === 226) { var name_8 = p.name; - var type = sourceType.flags & 1 /* Any */ ? sourceType : + var type = sourceType.flags & 1 ? sourceType : getTypeOfPropertyOfType(sourceType, name_8.text) || - isNumericLiteralName(name_8.text) && getIndexTypeOfType(sourceType, 1 /* Number */) || - getIndexTypeOfType(sourceType, 0 /* String */); + isNumericLiteralName(name_8.text) && getIndexTypeOfType(sourceType, 1) || + getIndexTypeOfType(sourceType, 0); if (type) { checkDestructuringAssignment(p.initializer || name_8, type); } @@ -18125,17 +14983,14 @@ var ts; return sourceType; } function checkArrayLiteralAssignment(node, sourceType, contextualMapper) { - // This elementType will be used if the specific property corresponding to this index is not - // present (aka the tuple element property). This call also checks that the parentType is in - // fact an iterable or array (depending on target language). var elementType = checkIteratedTypeOrElementType(sourceType, node, false) || unknownType; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176 /* OmittedExpression */) { - if (e.kind !== 174 /* SpreadElementExpression */) { + if (e.kind !== 176) { + if (e.kind !== 174) { var propName = "" + i; - var type = sourceType.flags & 1 /* Any */ ? sourceType : + var type = sourceType.flags & 1 ? sourceType : isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) : elementType; @@ -18157,7 +15012,7 @@ var ts; } else { var restExpression = e.expression; - if (restExpression.kind === 170 /* BinaryExpression */ && restExpression.operatorToken.kind === 53 /* EqualsToken */) { + if (restExpression.kind === 170 && restExpression.operatorToken.kind === 53) { error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } else { @@ -18170,14 +15025,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 170 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { + if (target.kind === 170 && target.operatorToken.kind === 53) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 155 /* ObjectLiteralExpression */) { + if (target.kind === 155) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 154 /* ArrayLiteralExpression */) { + if (target.kind === 154) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -18190,59 +15045,47 @@ var ts; return sourceType; } function checkBinaryExpression(node, contextualMapper) { - // Grammar checking if (ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { - // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an - // Assignment operator(11.13) or of a PostfixExpression(11.3) checkGrammarEvalOrArgumentsInStrictMode(node, node.left); } var operator = node.operatorToken.kind; - if (operator === 53 /* EqualsToken */ && (node.left.kind === 155 /* ObjectLiteralExpression */ || node.left.kind === 154 /* ArrayLiteralExpression */)) { + if (operator === 53 && (node.left.kind === 155 || node.left.kind === 154)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); var rightType = checkExpression(node.right, contextualMapper); switch (operator) { - case 35 /* AsteriskToken */: - case 56 /* AsteriskEqualsToken */: - case 36 /* SlashToken */: - case 57 /* SlashEqualsToken */: - case 37 /* PercentToken */: - case 58 /* PercentEqualsToken */: - case 34 /* MinusToken */: - case 55 /* MinusEqualsToken */: - case 40 /* LessThanLessThanToken */: - case 59 /* LessThanLessThanEqualsToken */: - case 41 /* GreaterThanGreaterThanToken */: - case 60 /* GreaterThanGreaterThanEqualsToken */: - case 42 /* GreaterThanGreaterThanGreaterThanToken */: - case 61 /* GreaterThanGreaterThanGreaterThanEqualsToken */: - case 44 /* BarToken */: - case 63 /* BarEqualsToken */: - case 45 /* CaretToken */: - case 64 /* CaretEqualsToken */: - case 43 /* AmpersandToken */: - case 62 /* AmpersandEqualsToken */: - // TypeScript 1.0 spec (April 2014): 4.15.1 - // These operators require their operands to be of type Any, the Number primitive type, - // or an enum type. Operands of an enum type are treated - // as having the primitive type Number. If one operand is the null or undefined value, - // it is treated as having the type of the other operand. - // The result is always of the Number primitive type. - if (leftType.flags & (32 /* Undefined */ | 64 /* Null */)) + case 35: + case 56: + case 36: + case 57: + case 37: + case 58: + case 34: + case 55: + case 40: + case 59: + case 41: + case 60: + case 42: + case 61: + case 44: + case 63: + case 45: + case 64: + case 43: + case 62: + if (leftType.flags & (32 | 64)) leftType = rightType; - if (rightType.flags & (32 /* Undefined */ | 64 /* Null */)) + if (rightType.flags & (32 | 64)) rightType = leftType; var suggestedOperator; - // if a user tries to apply a bitwise operator to 2 boolean operands - // try and return them a helpful suggestion - if ((leftType.flags & 8 /* Boolean */) && - (rightType.flags & 8 /* Boolean */) && + if ((leftType.flags & 8) && + (rightType.flags & 8) && (suggestedOperator = getSuggestedBooleanOperator(node.operatorToken.kind)) !== undefined) { error(node, ts.Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, ts.tokenToString(node.operatorToken.kind), ts.tokenToString(suggestedOperator)); } else { - // otherwise just check each operand separately and report errors as normal var leftOk = checkArithmeticOperandType(node.left, leftType, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); var rightOk = checkArithmeticOperandType(node.right, rightType, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); if (leftOk && rightOk) { @@ -18250,33 +15093,23 @@ var ts; } } return numberType; - case 33 /* PlusToken */: - case 54 /* PlusEqualsToken */: - // TypeScript 1.0 spec (April 2014): 4.15.2 - // The binary + operator requires both operands to be of the Number primitive type or an enum type, - // or at least one of the operands to be of type Any or the String primitive type. - // If one operand is the null or undefined value, it is treated as having the type of the other operand. - if (leftType.flags & (32 /* Undefined */ | 64 /* Null */)) + case 33: + case 54: + if (leftType.flags & (32 | 64)) leftType = rightType; - if (rightType.flags & (32 /* Undefined */ | 64 /* Null */)) + if (rightType.flags & (32 | 64)) rightType = leftType; var resultType; - if (allConstituentTypesHaveKind(leftType, 132 /* NumberLike */) && allConstituentTypesHaveKind(rightType, 132 /* NumberLike */)) { - // Operands of an enum type are treated as having the primitive type Number. - // If both operands are of the Number primitive type, the result is of the Number primitive type. + if (allConstituentTypesHaveKind(leftType, 132) && allConstituentTypesHaveKind(rightType, 132)) { resultType = numberType; } else { - if (allConstituentTypesHaveKind(leftType, 258 /* StringLike */) || allConstituentTypesHaveKind(rightType, 258 /* StringLike */)) { - // If one or both operands are of the String primitive type, the result is of the String primitive type. + if (allConstituentTypesHaveKind(leftType, 258) || allConstituentTypesHaveKind(rightType, 258)) { resultType = stringType; } - else if (leftType.flags & 1 /* Any */ || rightType.flags & 1 /* Any */) { - // Otherwise, the result is of type Any. - // NOTE: unknown type here denotes error type. Old compiler treated this case as any type so do we. + else if (leftType.flags & 1 || rightType.flags & 1) { resultType = anyType; } - // Symbols are not allowed at all in arithmetic expressions if (resultType && !checkForDisallowedESSymbolOperand(operator)) { return resultType; } @@ -18285,44 +15118,42 @@ var ts; reportOperatorError(); return anyType; } - if (operator === 54 /* PlusEqualsToken */) { + if (operator === 54) { checkAssignmentOperator(resultType); } return resultType; - case 24 /* LessThanToken */: - case 25 /* GreaterThanToken */: - case 26 /* LessThanEqualsToken */: - case 27 /* GreaterThanEqualsToken */: + case 24: + case 25: + case 26: + case 27: if (!checkForDisallowedESSymbolOperand(operator)) { return booleanType; } - // Fall through - case 28 /* EqualsEqualsToken */: - case 29 /* ExclamationEqualsToken */: - case 30 /* EqualsEqualsEqualsToken */: - case 31 /* ExclamationEqualsEqualsToken */: + case 28: + case 29: + case 30: + case 31: if (!isTypeAssignableTo(leftType, rightType) && !isTypeAssignableTo(rightType, leftType)) { reportOperatorError(); } return booleanType; - case 87 /* InstanceOfKeyword */: + case 87: return checkInstanceOfExpression(node, leftType, rightType); - case 86 /* InKeyword */: + case 86: return checkInExpression(node, leftType, rightType); - case 48 /* AmpersandAmpersandToken */: + case 48: return rightType; - case 49 /* BarBarToken */: + case 49: return getUnionType([leftType, rightType]); - case 53 /* EqualsToken */: + case 53: checkAssignmentOperator(rightType); return rightType; - case 23 /* CommaToken */: + case 23: return rightType; } - // Return true if there was no error, false if there was an error. function checkForDisallowedESSymbolOperand(operator) { - var offendingSymbolOperand = someConstituentTypeHasKind(leftType, 1048576 /* ESSymbol */) ? node.left : - someConstituentTypeHasKind(rightType, 1048576 /* ESSymbol */) ? node.right : + var offendingSymbolOperand = someConstituentTypeHasKind(leftType, 1048576) ? node.left : + someConstituentTypeHasKind(rightType, 1048576) ? node.right : undefined; if (offendingSymbolOperand) { error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator)); @@ -18332,31 +15163,23 @@ var ts; } function getSuggestedBooleanOperator(operator) { switch (operator) { - case 44 /* BarToken */: - case 63 /* BarEqualsToken */: - return 49 /* BarBarToken */; - case 45 /* CaretToken */: - case 64 /* CaretEqualsToken */: - return 31 /* ExclamationEqualsEqualsToken */; - case 43 /* AmpersandToken */: - case 62 /* AmpersandEqualsToken */: - return 48 /* AmpersandAmpersandToken */; + case 44: + case 63: + return 49; + case 45: + case 64: + return 31; + case 43: + case 62: + return 48; default: return undefined; } } function checkAssignmentOperator(valueType) { - if (produceDiagnostics && operator >= 53 /* FirstAssignment */ && operator <= 64 /* LastAssignment */) { - // TypeScript 1.0 spec (April 2014): 4.17 - // An assignment of the form - // VarExpr = ValueExpr - // requires VarExpr to be classified as a reference - // A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1) - // and the type of the non - compound operation to be assignable to the type of VarExpr. + if (produceDiagnostics && operator >= 53 && operator <= 64) { var ok = checkReferenceExpression(node.left, ts.Diagnostics.Invalid_left_hand_side_of_assignment_expression, ts.Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant); - // Use default messages if (ok) { - // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported checkTypeAssignableTo(valueType, leftType, node.left, undefined); } } @@ -18366,8 +15189,7 @@ var ts; } } function checkYieldExpression(node) { - // Grammar checking - if (!(node.parserContextFlags & 4 /* Yield */)) { + if (!(node.parserContextFlags & 4)) { grammarErrorOnFirstToken(node, ts.Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration); } else { @@ -18381,11 +15203,6 @@ var ts; return getUnionType([type1, type2]); } function checkTemplateExpression(node) { - // We just want to check each expressions, but we are unconcerned with - // the type of each expression, as any value may be coerced into a string. - // It is worth asking whether this is what we really want though. - // A place where we actually *are* concerned with the expressions' types are - // in tagged templates. ts.forEach(node.templateSpans, function (templateSpan) { checkExpression(templateSpan.expression); }); @@ -18406,21 +15223,14 @@ var ts; return links.resolvedType; } function checkPropertyAssignment(node, contextualMapper) { - // Do not use hasDynamicName here, because that returns false for well known symbols. - // We want to perform checkComputedPropertyName for all computed properties, including - // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 128) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); } function checkObjectLiteralMethod(node, contextualMapper) { - // Grammar checking checkGrammarMethod(node); - // Do not use hasDynamicName here, because that returns false for well known symbols. - // We want to perform checkComputedPropertyName for all computed properties, including - // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 128) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -18445,16 +15255,9 @@ var ts; checkGrammarIdentifierInStrictMode(node); return checkExpressionOrQualifiedName(node, contextualMapper); } - // Checks an expression and returns its type. The contextualMapper parameter serves two purposes: When - // contextualMapper is not undefined and not equal to the identityMapper function object it indicates that the - // expression is being inferentially typed (section 4.12.2 in spec) and provides the type mapper to use in - // conjunction with the generic contextual type. When contextualMapper is equal to the identityMapper function - // object, it serves as an indicator that all contained function and arrow expressions should be considered to - // have the wildcard function type; this form of type check is used during overload resolution to exclude - // contextually typed function and arrow expressions in the initial phase. function checkExpressionOrQualifiedName(node, contextualMapper) { var type; - if (node.kind == 127 /* QualifiedName */) { + if (node.kind == 127) { type = checkQualifiedName(node); } else { @@ -18462,13 +15265,9 @@ var ts; type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); } if (isConstEnumObjectType(type)) { - // enum object type for const enums are only permitted in: - // - 'left' in property access - // - 'object' in indexed access - // - target in rhs of import statement - var ok = (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.expression === node) || - (node.parent.kind === 157 /* ElementAccessExpression */ && node.parent.expression === node) || - ((node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 156 && node.parent.expression === node) || + (node.parent.kind === 157 && node.parent.expression === node) || + ((node.kind === 65 || node.kind === 127) && isInRightSideOfImportOrExportAssignment(node)); if (!ok) { error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment); } @@ -18476,82 +15275,79 @@ var ts; return type; } function checkNumericLiteral(node) { - // Grammar checking checkGrammarNumericLiteral(node); return numberType; } function checkExpressionWorker(node, contextualMapper) { switch (node.kind) { - case 65 /* Identifier */: + case 65: return checkIdentifier(node); - case 93 /* ThisKeyword */: + case 93: return checkThisExpression(node); - case 91 /* SuperKeyword */: + case 91: return checkSuperExpression(node); - case 89 /* NullKeyword */: + case 89: return nullType; - case 95 /* TrueKeyword */: - case 80 /* FalseKeyword */: + case 95: + case 80: return booleanType; - case 7 /* NumericLiteral */: + case 7: return checkNumericLiteral(node); - case 172 /* TemplateExpression */: + case 172: return checkTemplateExpression(node); - case 8 /* StringLiteral */: - case 10 /* NoSubstitutionTemplateLiteral */: + case 8: + case 10: return stringType; - case 9 /* RegularExpressionLiteral */: + case 9: return globalRegExpType; - case 154 /* ArrayLiteralExpression */: + case 154: return checkArrayLiteral(node, contextualMapper); - case 155 /* ObjectLiteralExpression */: + case 155: return checkObjectLiteral(node, contextualMapper); - case 156 /* PropertyAccessExpression */: + case 156: return checkPropertyAccessExpression(node); - case 157 /* ElementAccessExpression */: + case 157: return checkIndexedAccess(node); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 158: + case 159: return checkCallExpression(node); - case 160 /* TaggedTemplateExpression */: + case 160: return checkTaggedTemplateExpression(node); - case 161 /* TypeAssertionExpression */: + case 161: return checkTypeAssertion(node); - case 162 /* ParenthesizedExpression */: + case 162: return checkExpression(node.expression, contextualMapper); - case 175 /* ClassExpression */: + case 175: return checkClassExpression(node); - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 163: + case 164: return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 166 /* TypeOfExpression */: + case 166: return checkTypeOfExpression(node); - case 165 /* DeleteExpression */: + case 165: return checkDeleteExpression(node); - case 167 /* VoidExpression */: + case 167: return checkVoidExpression(node); - case 168 /* PrefixUnaryExpression */: + case 168: return checkPrefixUnaryExpression(node); - case 169 /* PostfixUnaryExpression */: + case 169: return checkPostfixUnaryExpression(node); - case 170 /* BinaryExpression */: + case 170: return checkBinaryExpression(node, contextualMapper); - case 171 /* ConditionalExpression */: + case 171: return checkConditionalExpression(node, contextualMapper); - case 174 /* SpreadElementExpression */: + case 174: return checkSpreadElementExpression(node, contextualMapper); - case 176 /* OmittedExpression */: + case 176: return undefinedType; - case 173 /* YieldExpression */: + case 173: checkYieldExpression(node); return unknownType; } return unknownType; } - // DECLARATION AND STATEMENT TYPE CHECKING function checkTypeParameter(node) { checkGrammarDeclarationNameInStrictMode(node); - // Grammar Checking if (node.expression) { grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); } @@ -18560,7 +15356,6 @@ var ts; checkTypeParameterHasIllegalReferencesInConstraint(node); checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); } - // TODO: Check multiple declarations are identical } function checkParameter(node) { // Grammar checking @@ -18569,33 +15364,29 @@ var ts; // or if its FunctionBody is strict code(11.1.5). // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) - // Grammar checking checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEvalOrArgumentsInStrictMode(node, node.name); checkVariableLikeDeclaration(node); var func = ts.getContainingFunction(node); - if (node.flags & 112 /* AccessibilityModifier */) { + if (node.flags & 112) { func = ts.getContainingFunction(node); - if (!(func.kind === 136 /* Constructor */ && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 136 && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } if (node.questionToken && ts.isBindingPattern(node.name) && func.body) { error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature); } - // Only check rest parameter type if it's not a binding pattern. Since binding patterns are - // not allowed in a rest parameter, we already have an error from checkGrammarParameterList. if (node.dotDotDotToken && !ts.isBindingPattern(node.name) && !isArrayType(getTypeOfSymbol(node.symbol))) { error(node, ts.Diagnostics.A_rest_parameter_must_be_of_an_array_type); } } function checkSignatureDeclaration(node) { - // Grammar checking - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 141) { checkGrammarIndexSignature(node); } - else if (node.kind === 143 /* FunctionType */ || node.kind === 201 /* FunctionDeclaration */ || node.kind === 144 /* ConstructorType */ || - node.kind === 139 /* CallSignature */ || node.kind === 136 /* Constructor */ || - node.kind === 140 /* ConstructSignature */) { + else if (node.kind === 143 || node.kind === 201 || node.kind === 144 || + node.kind === 139 || node.kind === 136 || + node.kind === 140) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); @@ -18607,10 +15398,10 @@ var ts; checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 140 /* ConstructSignature */: + case 140: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 139 /* CallSignature */: + case 139: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -18619,17 +15410,12 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 203 /* InterfaceDeclaration */) { + if (node.kind === 203) { var nodeSymbol = getSymbolOfNode(node); - // in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declaration - // to prevent this run check only for the first declaration of a given kind if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { return; } } - // TypeScript 1.0 spec (April 2014) - // 3.7.4: An object type can contain at most one string index signature and one numeric index signature. - // 8.5: A class declaration can have at most one string index member declaration and one numeric index member declaration var indexSymbol = getIndexSymbol(getSymbolOfNode(node)); if (indexSymbol) { var seenNumericIndexer = false; @@ -18639,7 +15425,7 @@ var ts; var declaration = decl; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 122 /* StringKeyword */: + case 122: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -18647,7 +15433,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 120 /* NumberKeyword */: + case 120: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -18661,29 +15447,22 @@ var ts; } } function checkPropertyDeclaration(node) { - // Grammar checking checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarProperty(node) || checkGrammarComputedPropertyName(node.name); checkVariableLikeDeclaration(node); } function checkMethodDeclaration(node) { - // Grammar checking checkGrammarMethod(node) || checkGrammarComputedPropertyName(node.name); - // Grammar checking for modifiers is done inside the function checkGrammarFunctionLikeDeclaration checkFunctionLikeDeclaration(node); } function checkConstructorDeclaration(node) { - // Grammar check on signature of constructor and modifier of the constructor is done in checkSignatureDeclaration function. checkSignatureDeclaration(node); - // Grammar check for checking only related to constructoDeclaration checkGrammarConstructorTypeParameters(node) || checkGrammarConstructorTypeAnnotation(node); checkSourceElement(node.body); var symbol = getSymbolOfNode(node); var firstDeclaration = ts.getDeclarationOfKind(symbol, node.kind); - // Only type check the symbol once if (node === firstDeclaration) { checkFunctionOrConstructorSymbol(symbol); } - // exit early in the case of signature - super checks are not relevant to them if (ts.nodeIsMissing(node.body)) { return; } @@ -18691,51 +15470,43 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 158 /* CallExpression */ && n.expression.kind === 91 /* SuperKeyword */; + return n.kind === 158 && n.expression.kind === 91; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 155 /* ObjectLiteralExpression */: return false; + case 163: + case 201: + case 164: + case 155: return false; default: return ts.forEachChild(n, containsSuperCall); } } function markThisReferencesAsErrors(n) { - if (n.kind === 93 /* ThisKeyword */) { + if (n.kind === 93) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 163 /* FunctionExpression */ && n.kind !== 201 /* FunctionDeclaration */) { + else if (n.kind !== 163 && n.kind !== 201) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 133 /* PropertyDeclaration */ && - !(n.flags & 128 /* Static */) && + return n.kind === 133 && + !(n.flags & 128) && !!n.initializer; } - // TS 1.0 spec (April 2014): 8.3.2 - // Constructors of classes with no extends clause may not contain super calls, whereas - // constructors of derived classes must contain at least one super call somewhere in their function body. if (ts.getClassExtendsHeritageClauseElement(node.parent)) { if (containsSuperCall(node.body)) { - // The first statement in the body of a constructor must be a super call if both of the following are true: - // - The containing class is a derived class. - // - The constructor declares parameter properties - // or the containing class declares instance member variables with initializers. var superCallShouldBeFirst = ts.forEach(node.parent.members, isInstancePropertyWithInitializer) || - ts.forEach(node.parameters, function (p) { return p.flags & (16 /* Public */ | 32 /* Private */ | 64 /* Protected */); }); + ts.forEach(node.parameters, function (p) { return p.flags & (16 | 32 | 64); }); if (superCallShouldBeFirst) { var statements = node.body.statements; - if (!statements.length || statements[0].kind !== 183 /* ExpressionStatement */ || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 183 || !isSuperCallExpression(statements[0].expression)) { error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties); } else { - // In such a required super call, it is a compile-time error for argument expressions to reference this. markThisReferencesAsErrors(statements[0].expression); } } @@ -18747,26 +15518,21 @@ var ts; } function checkAccessorDeclaration(node) { if (produceDiagnostics) { - // Grammar checking accessors checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 137 /* GetAccessor */) { + if (node.kind === 137) { if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) { error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement); } } if (!ts.hasDynamicName(node)) { - // TypeScript 1.0 spec (April 2014): 8.4.3 - // Accessors for the same member name must specify the same accessibility. - var otherKind = node.kind === 137 /* GetAccessor */ ? 138 /* SetAccessor */ : 137 /* GetAccessor */; + var otherKind = node.kind === 137 ? 138 : 137; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { - if (((node.flags & 112 /* AccessibilityModifier */) !== (otherAccessor.flags & 112 /* AccessibilityModifier */))) { + if (((node.flags & 112) !== (otherAccessor.flags & 112))) { error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility); } var currentAccessorType = getAnnotatedAccessorType(node); var otherAccessorType = getAnnotatedAccessorType(otherAccessor); - // TypeScript 1.0 spec (April 2014): 4.5 - // If both accessors include type annotations, the specified types must be identical. if (currentAccessorType && otherAccessorType) { if (!isTypeIdenticalTo(currentAccessorType, otherAccessorType)) { error(node, ts.Diagnostics.get_and_set_accessor_must_have_the_same_type); @@ -18790,11 +15556,9 @@ var ts; return checkTypeReferenceOrExpressionWithTypeArguments(node); } function checkTypeReferenceOrExpressionWithTypeArguments(node) { - // Grammar checking checkGrammarTypeArguments(node, node.typeArguments); var type = getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); if (type !== unknownType && node.typeArguments) { - // Do type argument local checks only if referenced type is successfully resolved var len = node.typeArguments.length; for (var i = 0; i < len; i++) { checkSourceElement(node.typeArguments[i]); @@ -18821,7 +15585,6 @@ var ts; checkSourceElement(node.elementType); } function checkTupleType(node) { - // Grammar checking var hasErrorFromDisallowedTrailingComma = checkGrammarForDisallowedTrailingComma(node.elementTypes); if (!hasErrorFromDisallowedTrailingComma && node.elementTypes.length === 0) { grammarErrorOnNode(node, ts.Diagnostics.A_tuple_type_element_list_cannot_be_empty); @@ -18832,7 +15595,7 @@ var ts; ts.forEach(node.types, checkSourceElement); } function isPrivateWithinAmbient(node) { - return (node.flags & 32 /* Private */) && ts.isInAmbientContext(node); + return (node.flags & 32) && ts.isInAmbientContext(node); } function checkSpecializedSignatureDeclaration(signatureDeclarationNode) { if (!produceDiagnostics) { @@ -18842,21 +15605,14 @@ var ts; if (!signature.hasStringLiterals) { return; } - // TypeScript 1.0 spec (April 2014): 3.7.2.2 - // Specialized signatures are not permitted in conjunction with a function body if (ts.nodeIsPresent(signatureDeclarationNode.body)) { error(signatureDeclarationNode, ts.Diagnostics.A_signature_with_an_implementation_cannot_use_a_string_literal_type); return; } - // TypeScript 1.0 spec (April 2014): 3.7.2.4 - // Every specialized call or construct signature in an object type must be assignable - // to at least one non-specialized call or construct signature in the same object type var signaturesToCheck; - // Unnamed (call\construct) signatures in interfaces are inherited and not shadowed so examining just node symbol won't give complete answer. - // Use declaring type to obtain full list of signatures. - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 203 /* InterfaceDeclaration */) { - ts.Debug.assert(signatureDeclarationNode.kind === 139 /* CallSignature */ || signatureDeclarationNode.kind === 140 /* ConstructSignature */); - var signatureKind = signatureDeclarationNode.kind === 139 /* CallSignature */ ? 0 /* Call */ : 1 /* Construct */; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 203) { + ts.Debug.assert(signatureDeclarationNode.kind === 139 || signatureDeclarationNode.kind === 140); + var signatureKind = signatureDeclarationNode.kind === 139 ? 0 : 1; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -18874,12 +15630,11 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 203 /* InterfaceDeclaration */ && ts.isInAmbientContext(n)) { - if (!(flags & 2 /* Ambient */)) { - // It is nested in an ambient context, which means it is automatically exported - flags |= 1 /* Export */; + if (n.parent.kind !== 203 && ts.isInAmbientContext(n)) { + if (!(flags & 2)) { + flags |= 1; } - flags |= 2 /* Ambient */; + flags |= 2; } return flags & flagsToCheck; } @@ -18888,29 +15643,22 @@ var ts; return; } function getCanonicalOverload(overloads, implementation) { - // Consider the canonical set of flags to be the flags of the bodyDeclaration or the first declaration - // Error on all deviations from this canonical set of flags - // The caveat is that if some overloads are defined in lib.d.ts, we don't want to - // report the errors on those. To achieve this, we will say that the implementation is - // the canonical signature only if it is in the same container as the first overload var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent; return implementationSharesContainerWithFirstOverload ? implementation : overloads[0]; } function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck, someOverloadFlags, allOverloadFlags) { - // Error if some overloads have a flag that is not shared by all overloads. To find the - // deviations, we XOR someOverloadFlags with allOverloadFlags var someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags; if (someButNotAllOverloadFlags !== 0) { var canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck); ts.forEach(overloads, function (o) { var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags; - if (deviation & 1 /* Export */) { + if (deviation & 1) { error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_exported_or_not_exported); } - else if (deviation & 2 /* Ambient */) { + else if (deviation & 2) { error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient); } - else if (deviation & (32 /* Private */ | 64 /* Protected */)) { + else if (deviation & (32 | 64)) { error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); } }); @@ -18927,7 +15675,7 @@ var ts; }); } } - var flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 32 /* Private */ | 64 /* Protected */; + var flagsToCheck = 1 | 2 | 32 | 64; var someNodeFlags = 0; var allNodeFlags = flagsToCheck; var someHaveQuestionToken = false; @@ -18937,7 +15685,7 @@ var ts; var lastSeenNonAmbientDeclaration; var previousDeclaration; var declarations = symbol.declarations; - var isConstructor = (symbol.flags & 16384 /* Constructor */) !== 0; + var isConstructor = (symbol.flags & 16384) !== 0; function reportImplementationExpectedError(node) { if (node.name && ts.nodeIsMissing(node.name)) { return; @@ -18954,12 +15702,10 @@ var ts; if (subsequentNode) { if (subsequentNode.kind === node.kind) { var errorNode_1 = subsequentNode.name || subsequentNode; - // TODO(jfreeman): These are methods, so handle computed name case if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { - // the only situation when this is possible (same kind\same name but different symbol) - mixed static and instance class members - ts.Debug.assert(node.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */); - ts.Debug.assert((node.flags & 128 /* Static */) !== (subsequentNode.flags & 128 /* Static */)); - var diagnostic = node.flags & 128 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; + ts.Debug.assert(node.kind === 135 || node.kind === 134); + ts.Debug.assert((node.flags & 128) !== (subsequentNode.flags & 128)); + var diagnostic = node.flags & 128 ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; error(errorNode_1, diagnostic); return; } @@ -18977,27 +15723,18 @@ var ts; error(errorNode, ts.Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); } } - // when checking exported function declarations across modules check only duplicate implementations - // names and consistency of modifiers are verified when we check local symbol - var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & 1536 /* Module */; + var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & 1536; var duplicateFunctionDeclaration = false; var multipleConstructorImplementation = false; for (var _i = 0; _i < declarations.length; _i++) { var current = declarations[_i]; var node = current; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 203 /* InterfaceDeclaration */ || node.parent.kind === 146 /* TypeLiteral */ || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 203 || node.parent.kind === 146 || inAmbientContext; if (inAmbientContextOrInterface) { - // check if declarations are consecutive only if they are non-ambient - // 1. ambient declarations can be interleaved - // i.e. this is legal - // declare function foo(); - // declare function bar(); - // declare function foo(); - // 2. mixing ambient and non-ambient declarations is a separate error that will be reported - do not want to report an extra one previousDeclaration = undefined; } - if (node.kind === 201 /* FunctionDeclaration */ || node.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */ || node.kind === 136 /* Constructor */) { + if (node.kind === 201 || node.kind === 135 || node.kind === 134 || node.kind === 136) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -19047,23 +15784,7 @@ var ts; if (bodyDeclaration) { var signatures = getSignaturesOfSymbol(symbol); var bodySignature = getSignatureFromDeclaration(bodyDeclaration); - // If the implementation signature has string literals, we will have reported an error in - // checkSpecializedSignatureDeclaration if (!bodySignature.hasStringLiterals) { - // TypeScript 1.0 spec (April 2014): 6.1 - // If a function declaration includes overloads, the overloads determine the call - // signatures of the type given to the function object - // and the function implementation signature must be assignable to that type - // - // TypeScript 1.0 spec (April 2014): 3.8.4 - // Note that specialized call and construct signatures (section 3.7.2.4) are not significant when determining assignment compatibility - // Consider checking against specialized signatures too. Not doing so creates a type hole: - // - // function g(x: "hi", y: boolean); - // function g(x: string, y: {}); - // function g(x: string, y: string) { } - // - // The implementation is completely unrelated to the specialized signature, yet we do not check this. for (var _a = 0; _a < signatures.length; _a++) { var signature = signatures[_a]; if (!signature.hasStringLiterals && !isSignatureAssignableTo(bodySignature, signature)) { @@ -19079,30 +15800,21 @@ var ts; if (!produceDiagnostics) { return; } - // Exports should be checked only if enclosing module contains both exported and non exported declarations. - // In case if all declarations are non-exported check is unnecessary. - // if localSymbol is defined on node then node itself is exported - check is required var symbol = node.localSymbol; if (!symbol) { - // local symbol is undefined => this declaration is non-exported. - // however symbol might contain other declarations that are exported symbol = getSymbolOfNode(node); - if (!(symbol.flags & 7340032 /* Export */)) { - // this is a pure local symbol (all declarations are non-exported) - no need to check anything + if (!(symbol.flags & 7340032)) { return; } } - // run the check only for the first declaration in the list if (ts.getDeclarationOfKind(symbol, node.kind) !== node) { return; } - // we use SymbolFlags.ExportValue, SymbolFlags.ExportType and SymbolFlags.ExportNamespace - // to denote disjoint declarationSpaces (without making new enum type). var exportedDeclarationSpaces = 0; var nonExportedDeclarationSpaces = 0; ts.forEach(symbol.declarations, function (d) { var declarationSpaces = getDeclarationSpaces(d); - if (getEffectiveDeclarationFlags(d, 1 /* Export */)) { + if (getEffectiveDeclarationFlags(d, 1)) { exportedDeclarationSpaces |= declarationSpaces; } else { @@ -19111,7 +15823,6 @@ var ts; }); var commonDeclarationSpace = exportedDeclarationSpaces & nonExportedDeclarationSpaces; if (commonDeclarationSpace) { - // declaration spaces for exported and non-exported declarations intersect ts.forEach(symbol.declarations, function (d) { if (getDeclarationSpaces(d) & commonDeclarationSpace) { error(d.name, ts.Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, ts.declarationNameToString(d.name)); @@ -19120,60 +15831,55 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 203 /* InterfaceDeclaration */: - return 2097152 /* ExportType */; - case 206 /* ModuleDeclaration */: - return d.name.kind === 8 /* StringLiteral */ || ts.getModuleInstanceState(d) !== 0 /* NonInstantiated */ - ? 4194304 /* ExportNamespace */ | 1048576 /* ExportValue */ - : 4194304 /* ExportNamespace */; - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - return 2097152 /* ExportType */ | 1048576 /* ExportValue */; - case 209 /* ImportEqualsDeclaration */: + case 203: + return 2097152; + case 206: + return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 + ? 4194304 | 1048576 + : 4194304; + case 202: + case 205: + return 2097152 | 1048576; + case 209: var result = 0; var target = resolveAlias(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); return result; default: - return 1048576 /* ExportValue */; + return 1048576; } } } - /** Check a decorator */ function checkDecorator(node) { var expression = node.expression; var exprType = checkExpression(expression); switch (node.parent.kind) { - case 202 /* ClassDeclaration */: + case 202: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); checkTypeAssignableTo(exprType, classDecoratorType, node); break; - case 133 /* PropertyDeclaration */: + case 133: checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); break; - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 135: + case 137: + case 138: var methodType = getTypeOfNode(node.parent); var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); checkTypeAssignableTo(exprType, methodDecoratorType, node); break; - case 130 /* Parameter */: + case 130: checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); break; } } - /** Checks a type reference node as an expression. */ function checkTypeNodeAsExpression(node) { - // When we are emitting type metadata for decorators, we need to try to check the type - // as if it were an expression so that we can emit the type in a value position when we - // serialize the type metadata. - if (node && node.kind === 142 /* TypeReference */) { + if (node && node.kind === 142) { var type = getTypeFromTypeNode(node); var shouldCheckIfUnknownType = type === unknownType && compilerOptions.separateCompilation; - if (!type || (!shouldCheckIfUnknownType && type.flags & (1048703 /* Intrinsic */ | 132 /* NumberLike */ | 258 /* StringLike */))) { + if (!type || (!shouldCheckIfUnknownType && type.flags & (1048703 | 132 | 258))) { return; } if (shouldCheckIfUnknownType || type.symbol.valueDeclaration) { @@ -19181,69 +15887,58 @@ var ts; } } } - /** - * Checks the type annotation of an accessor declaration or property declaration as - * an expression if it is a type reference to a type with a value declaration. - */ function checkTypeAnnotationAsExpression(node) { switch (node.kind) { - case 133 /* PropertyDeclaration */: + case 133: checkTypeNodeAsExpression(node.type); break; - case 130 /* Parameter */: + case 130: checkTypeNodeAsExpression(node.type); break; - case 135 /* MethodDeclaration */: + case 135: checkTypeNodeAsExpression(node.type); break; - case 137 /* GetAccessor */: + case 137: checkTypeNodeAsExpression(node.type); break; - case 138 /* SetAccessor */: + case 138: checkTypeNodeAsExpression(getSetAccessorTypeAnnotationNode(node)); break; } } - /** Checks the type annotation of the parameters of a function/method or the constructor of a class as expressions */ function checkParameterTypeAnnotationsAsExpressions(node) { - // ensure all type annotations with a value declaration are checked as an expression for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { var parameter = _a[_i]; checkTypeAnnotationAsExpression(parameter); } } - /** Check the decorators of a node */ function checkDecorators(node) { if (!node.decorators) { return; } - // skip this check for nodes that cannot have decorators. These should have already had an error reported by - // checkGrammarDecorators. if (!ts.nodeCanBeDecorated(node)) { return; } if (compilerOptions.emitDecoratorMetadata) { - // we only need to perform these checks if we are emitting serialized type metadata for the target of a decorator. switch (node.kind) { - case 202 /* ClassDeclaration */: + case 202: var constructor = ts.getFirstConstructorWithBody(node); if (constructor) { checkParameterTypeAnnotationsAsExpressions(constructor); } break; - case 135 /* MethodDeclaration */: + case 135: checkParameterTypeAnnotationsAsExpressions(node); - // fall-through - case 138 /* SetAccessor */: - case 137 /* GetAccessor */: - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 138: + case 137: + case 133: + case 130: checkTypeAnnotationAsExpression(node); break; } } emitDecorate = true; - if (node.kind === 130 /* Parameter */) { + if (node.kind === 130) { emitParam = true; } ts.forEach(node.decorators, checkDecorator); @@ -19263,29 +15958,18 @@ var ts; checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSignatureDeclaration(node); - // Do not use hasDynamicName here, because that returns false for well known symbols. - // We want to perform checkComputedPropertyName for all computed properties, including - // well known symbols. - if (node.name && node.name.kind === 128 /* ComputedPropertyName */) { - // This check will account for methods in class/interface declarations, - // as well as accessors in classes/object literals + if (node.name && node.name.kind === 128) { checkComputedPropertyName(node.name); } if (!ts.hasDynamicName(node)) { - // first we want to check the local symbol that contain this declaration - // - if node.localSymbol !== undefined - this is current declaration is exported and localSymbol points to the local symbol - // - if node.localSymbol === undefined - this node is non-exported so we can just pick the result of getSymbolOfNode var symbol = getSymbolOfNode(node); var localSymbol = node.localSymbol || symbol; var firstDeclaration = ts.getDeclarationOfKind(localSymbol, node.kind); - // Only type check the symbol once if (node === firstDeclaration) { checkFunctionOrConstructorSymbol(localSymbol); } if (symbol.parent) { - // run check once for the first declaration if (ts.getDeclarationOfKind(symbol, node.kind) === node) { - // run check on export symbol to check that modifiers agree across all exported declarations checkFunctionOrConstructorSymbol(symbol); } } @@ -19294,24 +15978,20 @@ var ts; if (node.type && !isAccessor(node.kind) && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } - // Report an implicit any error if there is no body, no explicit return type, and node is not a private method - // in an ambient context if (compilerOptions.noImplicitAny && ts.nodeIsMissing(node.body) && !node.type && !isPrivateWithinAmbient(node)) { reportImplicitAnyError(node, anyType); } } function checkBlock(node) { - // Grammar checking for SyntaxKind.Block - if (node.kind === 180 /* Block */) { + if (node.kind === 180) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 207 /* ModuleBlock */) { + if (ts.isFunctionBlock(node) || node.kind === 207) { checkFunctionExpressionBodies(node); } } function checkCollisionWithArgumentsInGeneratedCode(node) { - // no rest parameters \ declaration context \ overload - no codegen impact if (!ts.hasRestParameters(node) || ts.isInAmbientContext(node) || ts.nodeIsMissing(node.body)) { return; } @@ -19325,22 +16005,19 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 133 /* PropertyDeclaration */ || - node.kind === 132 /* PropertySignature */ || - node.kind === 135 /* MethodDeclaration */ || - node.kind === 134 /* MethodSignature */ || - node.kind === 137 /* GetAccessor */ || - node.kind === 138 /* SetAccessor */) { - // it is ok to have member named '_super' or '_this' - member access is always qualified + if (node.kind === 133 || + node.kind === 132 || + node.kind === 135 || + node.kind === 134 || + node.kind === 137 || + node.kind === 138) { return false; } if (ts.isInAmbientContext(node)) { - // ambient context - no codegen impact return false; } var root = getRootDeclaration(node); - if (root.kind === 130 /* Parameter */ && ts.nodeIsMissing(root.parent.body)) { - // just an overload - no codegen impact + if (root.kind === 130 && ts.nodeIsMissing(root.parent.body)) { return false; } return true; @@ -19350,12 +16027,11 @@ var ts; potentialThisCollisions.push(node); } } - // this function will run after checking the source file so 'CaptureThis' is correct for all nodes function checkIfThisIsCapturedInEnclosingScope(node) { var current = node; while (current) { - if (getNodeCheckFlags(current) & 4 /* CaptureThis */) { - var isDeclaration_1 = node.kind !== 65 /* Identifier */; + if (getNodeCheckFlags(current) & 4) { + var isDeclaration_1 = node.kind !== 65; if (isDeclaration_1) { error(node.name, ts.Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference); } @@ -19371,14 +16047,12 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - // bubble up and find containing type - var enclosingClass = ts.getAncestor(node, 202 /* ClassDeclaration */); - // if containing type was not found or it is ambient - exit (no codegen) + var enclosingClass = ts.getAncestor(node, 202); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } if (ts.getClassExtendsHeritageClauseElement(enclosingClass)) { - var isDeclaration_2 = node.kind !== 65 /* Identifier */; + var isDeclaration_2 = node.kind !== 65; if (isDeclaration_2) { error(node, ts.Diagnostics.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference); } @@ -19391,14 +16065,11 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { return; } - // Uninstantiated modules shouldnt do this check - if (node.kind === 206 /* ModuleDeclaration */ && ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { + if (node.kind === 206 && ts.getModuleInstanceState(node) !== 1) { return; } - // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent var parent = getDeclarationContainer(node); - if (parent.kind === 228 /* SourceFile */ && ts.isExternalModule(parent)) { - // If the declaration happens to be in external module, report error that require and exports are reserved keywords + if (parent.kind === 228 && ts.isExternalModule(parent)) { error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } } @@ -19406,57 +16077,28 @@ var ts; // - ScriptBody : StatementList // It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList // also occurs in the VarDeclaredNames of StatementList. - // - Block : { StatementList } - // It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList - // also occurs in the VarDeclaredNames of StatementList. - // Variable declarations are hoisted to the top of their function scope. They can shadow - // block scoped declarations, which bind tighter. this will not be flagged as duplicate definition - // by the binder as the declaration scope is different. - // A non-initialized declaration is a no-op as the block declaration will resolve before the var - // declaration. the problem is if the declaration has an initializer. this will act as a write to the - // block declared value. this is fine for let, but not const. - // Only consider declarations with initializers, uninitialized let declarations will not - // step on a let/const variable. - // Do not consider let and const declarations, as duplicate block-scoped declarations - // are handled by the binder. - // We are only looking for let declarations that step on let\const declarations from a - // different scope. e.g.: - // { - // const x = 0; // localDeclarationSymbol obtained after name resolution will correspond to this declaration - // let x = 0; // symbol for this declaration will be 'symbol' - // } - // skip block-scoped variables and parameters - if ((ts.getCombinedNodeFlags(node) & 12288 /* BlockScoped */) !== 0 || isParameterDeclaration(node)) { + if ((ts.getCombinedNodeFlags(node) & 12288) !== 0 || isParameterDeclaration(node)) { return; } - // skip variable declarations that don't have initializers - // NOTE: in ES6 spec initializer is required in variable declarations where name is binding pattern - // so we'll always treat binding elements as initialized - if (node.kind === 199 /* VariableDeclaration */ && !node.initializer) { + if (node.kind === 199 && !node.initializer) { return; } var symbol = getSymbolOfNode(node); - if (symbol.flags & 1 /* FunctionScopedVariable */) { - var localDeclarationSymbol = resolveName(node, node.name.text, 3 /* Variable */, undefined, undefined); + if (symbol.flags & 1) { + var localDeclarationSymbol = resolveName(node, node.name.text, 3, undefined, undefined); if (localDeclarationSymbol && localDeclarationSymbol !== symbol && - localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) { - if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 12288 /* BlockScoped */) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 200 /* VariableDeclarationList */); - var container = varDeclList.parent.kind === 181 /* VariableStatement */ && varDeclList.parent.parent + localDeclarationSymbol.flags & 2) { + if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 12288) { + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 200); + var container = varDeclList.parent.kind === 181 && varDeclList.parent.parent ? varDeclList.parent.parent : undefined; - // names of block-scoped and function scoped variables can collide only - // if block scoped variable is defined in the function\module\source file scope (because of variable hoisting) var namesShareScope = container && - (container.kind === 180 /* Block */ && ts.isFunctionLike(container.parent) || - container.kind === 207 /* ModuleBlock */ || - container.kind === 206 /* ModuleDeclaration */ || - container.kind === 228 /* SourceFile */); - // here we know that function scoped variable is shadowed by block scoped one - // if they are defined in the same scope - binder has already reported redeclaration error - // otherwise if variable has an initializer - show error that initialization will fail - // since LHS will be block scoped name instead of function scoped + (container.kind === 180 && ts.isFunctionLike(container.parent) || + container.kind === 207 || + container.kind === 206 || + container.kind === 228); if (!namesShareScope) { var name_9 = symbolToString(localDeclarationSymbol); error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name_9, name_9); @@ -19466,31 +16108,27 @@ var ts; } } function isParameterDeclaration(node) { - while (node.kind === 153 /* BindingElement */) { + while (node.kind === 153) { node = node.parent.parent; } - return node.kind === 130 /* Parameter */; + return node.kind === 130; } - // Check that a parameter initializer contains no references to parameters declared to the right of itself function checkParameterInitializer(node) { - if (getRootDeclaration(node).kind !== 130 /* Parameter */) { + if (getRootDeclaration(node).kind !== 130) { return; } var func = ts.getContainingFunction(node); visit(node.initializer); function visit(n) { - if (n.kind === 65 /* Identifier */) { + if (n.kind === 65) { var referencedSymbol = getNodeLinks(n).resolvedSymbol; - // check FunctionLikeDeclaration.locals (stores parameters\function local variable) - // if it contains entry with a specified name and if this entry matches the resolved symbol - if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455 /* Value */) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 130 /* Parameter */) { + if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455) === referencedSymbol) { + if (referencedSymbol.valueDeclaration.kind === 130) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; } if (referencedSymbol.valueDeclaration.pos < node.pos) { - // legal case - parameter initializer references some parameter strictly on left of current parameter declaration return; } } @@ -19502,31 +16140,23 @@ var ts; } } } - // Check variable, parameter, or property declaration function checkVariableLikeDeclaration(node) { checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSourceElement(node.type); - // For a computed property, just check the initializer and exit - // Do not use hasDynamicName here, because that returns false for well known symbols. - // We want to perform checkComputedPropertyName for all computed properties, including - // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 128) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); } } - // For a binding pattern, check contained binding elements if (ts.isBindingPattern(node.name)) { ts.forEach(node.name.elements, checkSourceElement); } - // For a parameter declaration with an initializer, error and exit if the containing function doesn't have a body - if (node.initializer && getRootDeclaration(node).kind === 130 /* Parameter */ && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && getRootDeclaration(node).kind === 130 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } - // For a binding pattern, validate the initializer and exit if (ts.isBindingPattern(node.name)) { if (node.initializer) { checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), node, undefined); @@ -19537,15 +16167,12 @@ var ts; var symbol = getSymbolOfNode(node); var type = getTypeOfVariableOrParameterOrProperty(symbol); if (node === symbol.valueDeclaration) { - // Node is the primary declaration of the symbol, just validate the initializer if (node.initializer) { checkTypeAssignableTo(checkExpressionCached(node.initializer), type, node, undefined); checkParameterInitializer(node); } } else { - // Node is a secondary declaration, check that type is identical to primary declaration and check that - // initializer is consistent with type associated with the node var declarationType = getWidenedTypeForVariableLikeDeclaration(node); if (type !== unknownType && declarationType !== unknownType && !isTypeIdenticalTo(type, declarationType)) { error(node.name, ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, ts.declarationNameToString(node.name), typeToString(type), typeToString(declarationType)); @@ -19554,10 +16181,9 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 133 /* PropertyDeclaration */ && node.kind !== 132 /* PropertySignature */) { - // We know we don't have a binding pattern or computed name here + if (node.kind !== 133 && node.kind !== 132) { checkExportsOnMergedDeclarations(node); - if (node.kind === 199 /* VariableDeclaration */ || node.kind === 153 /* BindingElement */) { + if (node.kind === 199 || node.kind === 153) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -19574,7 +16200,6 @@ var ts; return checkVariableLikeDeclaration(node); } function checkVariableStatement(node) { - // Grammar checking checkGrammarDecorators(node) || checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node) || checkGrammarModifiers(node) || checkGrammarVariableDeclarationList(node.declarationList) || checkGrammarForDisallowedLetOrConstStatement(node); ts.forEach(node.declarationList.declarations, checkSourceElement); } @@ -19587,45 +16212,40 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 180 /* Block */ || node.kind === 155 /* ObjectLiteralExpression */) { + if (node.kind === 180 || node.kind === 155) { return true; } node = node.parent; } } function checkExpressionStatement(node) { - // Grammar checking checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); } function checkIfStatement(node) { - // Grammar checking checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); checkSourceElement(node.thenStatement); checkSourceElement(node.elseStatement); } function checkDoStatement(node) { - // Grammar checking checkGrammarStatementInAmbientContext(node); checkSourceElement(node.statement); checkExpression(node.expression); } function checkWhileStatement(node) { - // Grammar checking checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); checkSourceElement(node.statement); } function checkForStatement(node) { - // Grammar checking if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 200 /* VariableDeclarationList */) { + if (node.initializer && node.initializer.kind == 200) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 200) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -19640,32 +16260,18 @@ var ts; } function checkForOfStatement(node) { checkGrammarForInOrForOfStatement(node); - // Check the LHS and RHS - // If the LHS is a declaration, just check it as a variable declaration, which will in turn check the RHS - // via checkRightHandSideOfForOf. - // If the LHS is an expression, check the LHS, as a destructuring assignment or as a reference. - // Then check that the RHS is assignable to it. - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 200) { checkForInOrForOfVariableDeclaration(node); } else { var varExpr = node.initializer; var iteratedType = checkRightHandSideOfForOf(node.expression); - // There may be a destructuring assignment on the left side - if (varExpr.kind === 154 /* ArrayLiteralExpression */ || varExpr.kind === 155 /* ObjectLiteralExpression */) { - // iteratedType may be undefined. In this case, we still want to check the structure of - // varExpr, in particular making sure it's a valid LeftHandSideExpression. But we'd like - // to short circuit the type relation checking as much as possible, so we pass the unknownType. + if (varExpr.kind === 154 || varExpr.kind === 155) { checkDestructuringAssignment(varExpr, iteratedType || unknownType); } else { var leftType = checkExpression(varExpr); - checkReferenceExpression(varExpr, ts.Diagnostics.Invalid_left_hand_side_in_for_of_statement, - /*constantVariableMessage*/ ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant); - // iteratedType will be undefined if the rightType was missing properties/signatures - // required to get its iteratedType (like [Symbol.iterator] or next). This may be - // because we accessed properties from anyType, or it may have led to an error inside - // getIteratedType. + checkReferenceExpression(varExpr, ts.Diagnostics.Invalid_left_hand_side_in_for_of_statement, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant); if (iteratedType) { checkTypeAssignableTo(iteratedType, leftType, varExpr, undefined); } @@ -19674,14 +16280,8 @@ var ts; checkSourceElement(node.statement); } function checkForInStatement(node) { - // Grammar checking checkGrammarForInOrForOfStatement(node); - // TypeScript 1.0 spec (April 2014): 5.4 - // In a 'for-in' statement of the form - // for (let VarDecl in Expr) Statement - // VarDecl must be a variable declaration without a type annotation that declares a variable of type Any, - // and Expr must be an expression of type Any, an object type, or a type parameter type. - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 200) { var variable = node.initializer.declarations[0]; if (variable && ts.isBindingPattern(variable.name)) { error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); @@ -19689,34 +16289,26 @@ var ts; checkForInOrForOfVariableDeclaration(node); } else { - // In a 'for-in' statement of the form - // for (Var in Expr) Statement - // Var must be an expression classified as a reference of type Any or the String primitive type, - // and Expr must be an expression of type Any, an object type, or a type parameter type. var varExpr = node.initializer; var leftType = checkExpression(varExpr); - if (varExpr.kind === 154 /* ArrayLiteralExpression */ || varExpr.kind === 155 /* ObjectLiteralExpression */) { + if (varExpr.kind === 154 || varExpr.kind === 155) { error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); } - else if (!allConstituentTypesHaveKind(leftType, 1 /* Any */ | 258 /* StringLike */)) { + else if (!allConstituentTypesHaveKind(leftType, 1 | 258)) { error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any); } else { - // run check only former check succeeded to avoid cascading errors checkReferenceExpression(varExpr, ts.Diagnostics.Invalid_left_hand_side_in_for_in_statement, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_previously_defined_constant); } } var rightType = checkExpression(node.expression); - // unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved - // in this case error about missing name is already reported - do not report extra one - if (!allConstituentTypesHaveKind(rightType, 1 /* Any */ | 48128 /* ObjectType */ | 512 /* TypeParameter */)) { + if (!allConstituentTypesHaveKind(rightType, 1 | 48128 | 512)) { error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter); } checkSourceElement(node.statement); } function checkForInOrForOfVariableDeclaration(iterationStatement) { var variableDeclarationList = iterationStatement.initializer; - // checkGrammarForInOrForOfStatement will check that there is exactly one declaration. if (variableDeclarationList.declarations.length >= 1) { var decl = variableDeclarationList.declarations[0]; checkVariableDeclaration(decl); @@ -19727,17 +16319,17 @@ var ts; return checkIteratedTypeOrElementType(expressionType, rhsExpression, true); } function checkIteratedTypeOrElementType(inputType, errorNode, allowStringInput) { - if (inputType.flags & 1 /* Any */) { + if (inputType.flags & 1) { return inputType; } - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { return checkIteratedType(inputType, errorNode) || anyType; } if (allowStringInput) { return checkElementTypeOfArrayOrString(inputType, errorNode); } if (isArrayLikeType(inputType)) { - var indexType = getIndexTypeOfType(inputType, 1 /* Number */); + var indexType = getIndexTypeOfType(inputType, 1); if (indexType) { return indexType; } @@ -19745,14 +16337,9 @@ var ts; error(errorNode, ts.Diagnostics.Type_0_is_not_an_array_type, typeToString(inputType)); return unknownType; } - /** - * When errorNode is undefined, it means we should not report any errors. - */ function checkIteratedType(iterable, errorNode) { - ts.Debug.assert(languageVersion >= 2 /* ES6 */); + ts.Debug.assert(languageVersion >= 2); var iteratedType = getIteratedType(iterable, errorNode); - // Now even though we have extracted the iteratedType, we will have to validate that the type - // passed in is actually an Iterable. if (errorNode && iteratedType) { checkTypeAssignableTo(iterable, createIterableType(iteratedType), errorNode); } @@ -19783,19 +16370,17 @@ var ts; // caller requested it. Then the caller can decide what to do in the case where there is no iterated // type. This is different from returning anyType, because that would signify that we have matched the // whole pattern and that T (above) is 'any'. - if (allConstituentTypesHaveKind(iterable, 1 /* Any */)) { + if (allConstituentTypesHaveKind(iterable, 1)) { return undefined; } - // As an optimization, if the type is instantiated directly using the globalIterableType (Iterable), - // then just grab its type argument. - if ((iterable.flags & 4096 /* Reference */) && iterable.target === globalIterableType) { + if ((iterable.flags & 4096) && iterable.target === globalIterableType) { return iterable.typeArguments[0]; } var iteratorFunction = getTypeOfPropertyOfType(iterable, ts.getPropertyNameForKnownSymbolName("iterator")); - if (iteratorFunction && allConstituentTypesHaveKind(iteratorFunction, 1 /* Any */)) { + if (iteratorFunction && allConstituentTypesHaveKind(iteratorFunction, 1)) { return undefined; } - var iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, 0 /* Call */) : emptyArray; + var iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, 0) : emptyArray; if (iteratorFunctionSignatures.length === 0) { if (errorNode) { error(errorNode, ts.Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator); @@ -19803,14 +16388,14 @@ var ts; return undefined; } var iterator = getUnionType(ts.map(iteratorFunctionSignatures, getReturnTypeOfSignature)); - if (allConstituentTypesHaveKind(iterator, 1 /* Any */)) { + if (allConstituentTypesHaveKind(iterator, 1)) { return undefined; } var iteratorNextFunction = getTypeOfPropertyOfType(iterator, "next"); - if (iteratorNextFunction && allConstituentTypesHaveKind(iteratorNextFunction, 1 /* Any */)) { + if (iteratorNextFunction && allConstituentTypesHaveKind(iteratorNextFunction, 1)) { return undefined; } - var iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, 0 /* Call */) : emptyArray; + var iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, 0) : emptyArray; if (iteratorNextFunctionSignatures.length === 0) { if (errorNode) { error(errorNode, ts.Diagnostics.An_iterator_must_have_a_next_method); @@ -19818,7 +16403,7 @@ var ts; return undefined; } var iteratorNextResult = getUnionType(ts.map(iteratorNextFunctionSignatures, getReturnTypeOfSignature)); - if (allConstituentTypesHaveKind(iteratorNextResult, 1 /* Any */)) { + if (allConstituentTypesHaveKind(iteratorNextResult, 1)) { return undefined; } var iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value"); @@ -19831,47 +16416,22 @@ var ts; return iteratorNextValue; } } - /** - * This function does the following steps: - * 1. Break up arrayOrStringType (possibly a union) into its string constituents and array constituents. - * 2. Take the element types of the array constituents. - * 3. Return the union of the element types, and string if there was a string constitutent. - * - * For example: - * string -> string - * number[] -> number - * string[] | number[] -> string | number - * string | number[] -> string | number - * string | string[] | number[] -> string | number - * - * It also errors if: - * 1. Some constituent is neither a string nor an array. - * 2. Some constituent is a string and target is less than ES5 (because in ES3 string is not indexable). - */ function checkElementTypeOfArrayOrString(arrayOrStringType, errorNode) { - ts.Debug.assert(languageVersion < 2 /* ES6 */); - // After we remove all types that are StringLike, we will know if there was a string constituent - // based on whether the remaining type is the same as the initial type. - var arrayType = removeTypesFromUnionType(arrayOrStringType, 258 /* StringLike */, true, true); + ts.Debug.assert(languageVersion < 2); + var arrayType = removeTypesFromUnionType(arrayOrStringType, 258, true, true); var hasStringConstituent = arrayOrStringType !== arrayType; var reportedError = false; if (hasStringConstituent) { - if (languageVersion < 1 /* ES5 */) { + if (languageVersion < 1) { error(errorNode, ts.Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher); reportedError = true; } - // Now that we've removed all the StringLike types, if no constituents remain, then the entire - // arrayOrStringType was a string. if (arrayType === emptyObjectType) { return stringType; } } if (!isArrayLikeType(arrayType)) { if (!reportedError) { - // Which error we report depends on whether there was a string constituent. For example, - // if the input type is number | string, we want to say that number is not an array type. - // But if the input was just number, we want to say that number is not an array type - // or a string type. var diagnostic = hasStringConstituent ? ts.Diagnostics.Type_0_is_not_an_array_type : ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type; @@ -19879,10 +16439,9 @@ var ts; } return hasStringConstituent ? stringType : unknownType; } - var arrayElementType = getIndexTypeOfType(arrayType, 1 /* Number */) || unknownType; + var arrayElementType = getIndexTypeOfType(arrayType, 1) || unknownType; if (hasStringConstituent) { - // This is just an optimization for the case where arrayOrStringType is string | string[] - if (arrayElementType.flags & 258 /* StringLike */) { + if (arrayElementType.flags & 258) { return stringType; } return getUnionType([arrayElementType, stringType]); @@ -19890,15 +16449,12 @@ var ts; return arrayElementType; } function checkBreakOrContinueStatement(node) { - // Grammar checking checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node); - // TODO: Check that target label is valid } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 137 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 138 /* SetAccessor */))); + return !!(node.kind === 137 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 138))); } function checkReturnStatement(node) { - // Grammar checking if (!checkGrammarStatementInAmbientContext(node)) { var functionBlock = ts.getContainingFunction(node); if (!functionBlock) { @@ -19910,11 +16466,11 @@ var ts; if (func) { var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); var exprType = checkExpressionCached(node.expression); - if (func.kind === 138 /* SetAccessor */) { + if (func.kind === 138) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } else { - if (func.kind === 136 /* Constructor */) { + if (func.kind === 136) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } @@ -19927,9 +16483,8 @@ var ts; } } function checkWithStatement(node) { - // Grammar checking for withStatement if (!checkGrammarStatementInAmbientContext(node)) { - if (node.parserContextFlags & 1 /* StrictMode */) { + if (node.parserContextFlags & 1) { grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); } } @@ -19937,14 +16492,12 @@ var ts; error(node.expression, ts.Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any); } function checkSwitchStatement(node) { - // Grammar checking checkGrammarStatementInAmbientContext(node); var firstDefaultClause; var hasDuplicateDefaultClause = false; var expressionType = checkExpression(node.expression); ts.forEach(node.caseBlock.clauses, function (clause) { - // Grammar check for duplicate default clauses, skip if we already report duplicate default clause - if (clause.kind === 222 /* DefaultClause */ && !hasDuplicateDefaultClause) { + if (clause.kind === 222 && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -19956,13 +16509,10 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 221 /* CaseClause */) { + if (produceDiagnostics && clause.kind === 221) { var caseClause = clause; - // TypeScript 1.0 spec (April 2014):5.9 - // In a 'switch' statement, each 'case' expression must be of a type that is assignable to or from the type of the 'switch' expression. var caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { - // check 'expressionType isAssignableTo caseType' failed, try the reversed check and report errors if it fails checkTypeAssignableTo(caseType, expressionType, caseClause.expression, undefined); } } @@ -19970,14 +16520,13 @@ var ts; }); } function checkLabeledStatement(node) { - // Grammar checking if (!checkGrammarStatementInAmbientContext(node)) { var current = node.parent; while (current) { if (ts.isFunctionLike(current)) { break; } - if (current.kind === 195 /* LabeledStatement */ && current.label.text === node.label.text) { + if (current.kind === 195 && current.label.text === node.label.text) { var sourceFile = ts.getSourceFileOfNode(node); grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNodeFromSourceText(sourceFile.text, node.label)); break; @@ -19985,11 +16534,9 @@ var ts; current = current.parent; } } - // ensure that label is unique checkSourceElement(node.statement); } function checkThrowStatement(node) { - // Grammar checking if (!checkGrammarStatementInAmbientContext(node)) { if (node.expression === undefined) { grammarErrorAfterFirstToken(node, ts.Diagnostics.Line_break_not_permitted_here); @@ -20000,14 +16547,12 @@ var ts; } } function checkTryStatement(node) { - // Grammar checking checkGrammarStatementInAmbientContext(node); checkBlock(node.tryBlock); var catchClause = node.catchClause; if (catchClause) { - // Grammar checking if (catchClause.variableDeclaration) { - if (catchClause.variableDeclaration.name.kind !== 65 /* Identifier */) { + if (catchClause.variableDeclaration.name.kind !== 65) { grammarErrorOnFirstToken(catchClause.variableDeclaration.name, ts.Diagnostics.Catch_clause_variable_name_must_be_an_identifier); } else if (catchClause.variableDeclaration.type) { @@ -20021,12 +16566,10 @@ var ts; var locals = catchClause.block.locals; if (locals && ts.hasProperty(locals, identifierName)) { var localSymbol = locals[identifierName]; - if (localSymbol && (localSymbol.flags & 2 /* BlockScopedVariable */) !== 0) { + if (localSymbol && (localSymbol.flags & 2) !== 0) { grammarErrorOnNode(localSymbol.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName); } } - // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the - // Catch production is eval or arguments checkGrammarEvalOrArgumentsInStrictMode(node, catchClause.variableDeclaration.name); } } @@ -20037,27 +16580,24 @@ var ts; } } function checkIndexConstraints(type) { - var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1 /* Number */); - var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0 /* String */); - var stringIndexType = getIndexTypeOfType(type, 0 /* String */); - var numberIndexType = getIndexTypeOfType(type, 1 /* Number */); + var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1); + var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0); + var stringIndexType = getIndexTypeOfType(type, 0); + var numberIndexType = getIndexTypeOfType(type, 1); if (stringIndexType || numberIndexType) { ts.forEach(getPropertiesOfObjectType(type), function (prop) { var propType = getTypeOfSymbol(prop); - checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */); - checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */); + checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0); + checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1); }); - if (type.flags & 1024 /* Class */ && type.symbol.valueDeclaration.kind === 202 /* ClassDeclaration */) { + if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 202) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; - // Only process instance properties with computed names here. - // Static properties cannot be in conflict with indexers, - // and properties with literal names were already checked. - if (!(member.flags & 128 /* Static */) && ts.hasDynamicName(member)) { + if (!(member.flags & 128) && ts.hasDynamicName(member)) { var propType = getTypeOfSymbol(member.symbol); - checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */); - checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */); + checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0); + checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1); } } } @@ -20065,9 +16605,8 @@ var ts; var errorNode; if (stringIndexType && numberIndexType) { errorNode = declaredNumberIndexer || declaredStringIndexer; - // condition 'errorNode === undefined' may appear if types does not declare nor string neither number indexer - if (!errorNode && (type.flags & 2048 /* Interface */)) { - var someBaseTypeHasBothIndexers = ts.forEach(getBaseTypes(type), function (base) { return getIndexTypeOfType(base, 0 /* String */) && getIndexTypeOfType(base, 1 /* Number */); }); + if (!errorNode && (type.flags & 2048)) { + var someBaseTypeHasBothIndexers = ts.forEach(getBaseTypes(type), function (base) { return getIndexTypeOfType(base, 0) && getIndexTypeOfType(base, 1); }); errorNode = someBaseTypeHasBothIndexers ? undefined : type.symbol.declarations[0]; } } @@ -20078,28 +16617,22 @@ var ts; if (!indexType) { return; } - // index is numeric and property name is not valid numeric literal - if (indexKind === 1 /* Number */ && !isNumericName(prop.valueDeclaration.name)) { + if (indexKind === 1 && !isNumericName(prop.valueDeclaration.name)) { return; } - // perform property check if property or indexer is declared in 'type' - // this allows to rule out cases when both property and indexer are inherited from the base class var errorNode; - if (prop.valueDeclaration.name.kind === 128 /* ComputedPropertyName */ || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 128 || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { errorNode = indexDeclaration; } - else if (containingType.flags & 2048 /* Interface */) { - // for interfaces property and indexer might be inherited from different bases - // check if any base class already has both property and indexer. - // check should be performed only if 'type' is the first type that brings property\indexer together + else if (containingType.flags & 2048) { var someBaseClassHasBothPropertyAndIndexer = ts.forEach(getBaseTypes(containingType), function (base) { return getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind); }); errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0]; } if (errorNode && !isTypeAssignableTo(propertyType, indexType)) { - var errorMessage = indexKind === 0 /* String */ + var errorMessage = indexKind === 0 ? ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2 : ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2; error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType)); @@ -20107,8 +16640,6 @@ var ts; } } function checkTypeNameIsReserved(name, message) { - // TS 1.0 spec (April 2014): 3.6.1 - // The predefined type keywords are reserved and cannot be used as names of user defined types. switch (name.text) { case "any": case "number": @@ -20119,7 +16650,6 @@ var ts; error(name, message, name.text); } } - // Check each type parameter and check that list has no duplicate type parameter declarations function checkTypeParameters(typeParameterDeclarations) { if (typeParameterDeclarations) { for (var i = 0, n = typeParameterDeclarations.length; i < n; i++) { @@ -20142,11 +16672,10 @@ var ts; } function checkClassDeclaration(node) { checkGrammarDeclarationNameInStrictMode(node); - // Grammar checking - if (node.parent.kind !== 207 /* ModuleBlock */ && node.parent.kind !== 228 /* SourceFile */) { + if (node.parent.kind !== 207 && node.parent.kind !== 228) { grammarErrorOnNode(node, ts.Diagnostics.class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration); } - if (!node.name && !(node.flags & 256 /* Default */)) { + if (!node.name && !(node.flags & 256)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } checkGrammarClassDeclarationHeritageClauses(node); @@ -20176,14 +16705,13 @@ var ts; checkTypeAssignableTo(type, baseType, node.name || node, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); var staticBaseType = getTypeOfSymbol(baseType.symbol); checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); - if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, 107455 /* Value */)) { + if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, 107455)) { error(baseTypeNode, ts.Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType)); } checkKindsOfPropertyMemberOverrides(type, baseType); } } if (baseTypes.length || (baseTypeNode && compilerOptions.separateCompilation)) { - // Check that base type can be evaluated as expression checkExpressionOrQualifiedName(baseTypeNode.expression); } var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node); @@ -20196,8 +16724,8 @@ var ts; if (produceDiagnostics) { var t = getTypeFromTypeNode(typeRefNode); if (t !== unknownType) { - var declaredType = (t.flags & 4096 /* Reference */) ? t.target : t; - if (declaredType.flags & (1024 /* Class */ | 2048 /* Interface */)) { + var declaredType = (t.flags & 4096) ? t.target : t; + if (declaredType.flags & (1024 | 2048)) { checkTypeAssignableTo(type, t, node.name || node, ts.Diagnostics.Class_0_incorrectly_implements_interface_1); } else { @@ -20214,9 +16742,7 @@ var ts; } } function getTargetSymbol(s) { - // if symbol is instantiated its flags are not copied from the 'target' - // so we'll need to get back original 'target' symbol to work with correct set of flags - return s.flags & 16777216 /* Instantiated */ ? getSymbolLinks(s).target : s; + return s.flags & 16777216 ? getSymbolLinks(s).target : s; } function checkKindsOfPropertyMemberOverrides(type, baseType) { // TypeScript 1.0 spec (April 2014): 8.2.3 @@ -20232,47 +16758,43 @@ var ts; // but not by other kinds of members. // Base class instance member variables and accessors can be overridden by // derived class instance member variables and accessors, but not by other kinds of members. - // NOTE: assignability is checked in checkClassDeclaration var baseProperties = getPropertiesOfObjectType(baseType); for (var _i = 0; _i < baseProperties.length; _i++) { var baseProperty = baseProperties[_i]; var base = getTargetSymbol(baseProperty); - if (base.flags & 134217728 /* Prototype */) { + if (base.flags & 134217728) { continue; } var derived = getTargetSymbol(getPropertyOfObjectType(type, base.name)); if (derived) { var baseDeclarationFlags = getDeclarationFlagsFromSymbol(base); var derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived); - if ((baseDeclarationFlags & 32 /* Private */) || (derivedDeclarationFlags & 32 /* Private */)) { - // either base or derived property is private - not override, skip it + if ((baseDeclarationFlags & 32) || (derivedDeclarationFlags & 32)) { continue; } - if ((baseDeclarationFlags & 128 /* Static */) !== (derivedDeclarationFlags & 128 /* Static */)) { - // value of 'static' is not the same for properties - not override, skip it + if ((baseDeclarationFlags & 128) !== (derivedDeclarationFlags & 128)) { continue; } - if ((base.flags & derived.flags & 8192 /* Method */) || ((base.flags & 98308 /* PropertyOrAccessor */) && (derived.flags & 98308 /* PropertyOrAccessor */))) { - // method is overridden with method or property/accessor is overridden with property/accessor - correct case + if ((base.flags & derived.flags & 8192) || ((base.flags & 98308) && (derived.flags & 98308))) { continue; } var errorMessage = void 0; - if (base.flags & 8192 /* Method */) { - if (derived.flags & 98304 /* Accessor */) { + if (base.flags & 8192) { + if (derived.flags & 98304) { errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; } else { - ts.Debug.assert((derived.flags & 4 /* Property */) !== 0); + ts.Debug.assert((derived.flags & 4) !== 0); errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property; } } - else if (base.flags & 4 /* Property */) { - ts.Debug.assert((derived.flags & 8192 /* Method */) !== 0); + else if (base.flags & 4) { + ts.Debug.assert((derived.flags & 8192) !== 0); errorMessage = ts.Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; } else { - ts.Debug.assert((base.flags & 98304 /* Accessor */) !== 0); - ts.Debug.assert((derived.flags & 8192 /* Method */) !== 0); + ts.Debug.assert((base.flags & 98304) !== 0); + ts.Debug.assert((derived.flags & 8192) !== 0); errorMessage = ts.Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function; } error(derived.valueDeclaration.name, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type)); @@ -20280,7 +16802,7 @@ var ts; } } function isAccessor(kind) { - return kind === 137 /* GetAccessor */ || kind === 138 /* SetAccessor */; + return kind === 137 || kind === 138; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -20289,9 +16811,6 @@ var ts; if (!list1 || !list2 || list1.length !== list2.length) { return false; } - // TypeScript 1.0 spec (April 2014): - // When a generic interface has multiple declarations, all declarations must have identical type parameter - // lists, i.e. identical type parameter names with identical constraints in identical order. for (var i = 0, len = list1.length; i < len; i++) { var tp1 = list1[i]; var tp2 = list2[i]; @@ -20343,23 +16862,20 @@ var ts; return ok; } function checkInterfaceDeclaration(node) { - // Grammar checking checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); checkTypeParameters(node.typeParameters); if (produceDiagnostics) { checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 203 /* InterfaceDeclaration */); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 203); if (symbol.declarations.length > 1) { if (node !== firstInterfaceDecl && !areTypeParametersIdentical(firstInterfaceDecl.typeParameters, node.typeParameters)) { error(node.name, ts.Diagnostics.All_declarations_of_an_interface_must_have_identical_type_parameters); } } - // Only check this symbol once if (node === firstInterfaceDecl) { var type = getDeclaredTypeOfSymbol(symbol); - // run subsequent checks only if first set succeeded if (checkInheritedPropertiesAreIdentical(type, node.name)) { ts.forEach(getBaseTypes(type), function (baseType) { checkTypeAssignableTo(type, baseType, node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1); @@ -20380,21 +16896,20 @@ var ts; } } function checkTypeAliasDeclaration(node) { - // Grammar checking checkGrammarDecorators(node) || checkGrammarModifiers(node); checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0); checkSourceElement(node.type); } function computeEnumMemberValues(node) { var nodeLinks = getNodeLinks(node); - if (!(nodeLinks.flags & 128 /* EnumValuesComputed */)) { + if (!(nodeLinks.flags & 128)) { var enumSymbol = getSymbolOfNode(node); var enumType = getDeclaredTypeOfSymbol(enumSymbol); var autoValue = 0; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 128 /* ComputedPropertyName */ && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 128 && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -20405,10 +16920,6 @@ var ts; error(initializer, ts.Diagnostics.In_const_enum_declarations_member_initializer_must_be_constant_expression); } else if (!ambient) { - // Only here do we need to check that the initializer is assignable to the enum type. - // If it is a constant value (not undefined), it is syntactically constrained to be a number. - // Also, we do not need to check this for ambients because there is already - // a syntax error if it is not a constant. checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, undefined); } } @@ -20428,24 +16939,24 @@ var ts; getNodeLinks(member).enumMemberValue = autoValue++; } }); - nodeLinks.flags |= 128 /* EnumValuesComputed */; + nodeLinks.flags |= 128; } function getConstantValueForEnumMemberInitializer(initializer) { return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 168 /* PrefixUnaryExpression */: + case 168: var value = evalConstant(e.operand); if (value === undefined) { return undefined; } switch (e.operator) { - case 33 /* PlusToken */: return value; - case 34 /* MinusToken */: return -value; - case 47 /* TildeToken */: return ~value; + case 33: return value; + case 34: return -value; + case 47: return ~value; } return undefined; - case 170 /* BinaryExpression */: + case 170: var left = evalConstant(e.left); if (left === undefined) { return undefined; @@ -20455,41 +16966,39 @@ var ts; return undefined; } switch (e.operatorToken.kind) { - case 44 /* BarToken */: return left | right; - case 43 /* AmpersandToken */: return left & right; - case 41 /* GreaterThanGreaterThanToken */: return left >> right; - case 42 /* GreaterThanGreaterThanGreaterThanToken */: return left >>> right; - case 40 /* LessThanLessThanToken */: return left << right; - case 45 /* CaretToken */: return left ^ right; - case 35 /* AsteriskToken */: return left * right; - case 36 /* SlashToken */: return left / right; - case 33 /* PlusToken */: return left + right; - case 34 /* MinusToken */: return left - right; - case 37 /* PercentToken */: return left % right; + case 44: return left | right; + case 43: return left & right; + case 41: return left >> right; + case 42: return left >>> right; + case 40: return left << right; + case 45: return left ^ right; + case 35: return left * right; + case 36: return left / right; + case 33: return left + right; + case 34: return left - right; + case 37: return left % right; } return undefined; - case 7 /* NumericLiteral */: + case 7: return +e.text; - case 162 /* ParenthesizedExpression */: + case 162: return evalConstant(e.expression); - case 65 /* Identifier */: - case 157 /* ElementAccessExpression */: - case 156 /* PropertyAccessExpression */: + case 65: + case 157: + case 156: var member = initializer.parent; var currentType = getTypeOfSymbol(getSymbolOfNode(member.parent)); var enumType; var propertyName; - if (e.kind === 65 /* Identifier */) { - // unqualified names can refer to member that reside in different declaration of the enum so just doing name resolution won't work. - // instead pick current enum type and later try to fetch member from the type + if (e.kind === 65) { enumType = currentType; propertyName = e.text; } else { var expression; - if (e.kind === 157 /* ElementAccessExpression */) { + if (e.kind === 157) { if (e.argumentExpression === undefined || - e.argumentExpression.kind !== 8 /* StringLiteral */) { + e.argumentExpression.kind !== 8) { return undefined; } expression = e.expression; @@ -20499,13 +17008,12 @@ var ts; expression = e.expression; propertyName = e.name.text; } - // expression part in ElementAccess\PropertyAccess should be either identifier or dottedName var current = expression; while (current) { - if (current.kind === 65 /* Identifier */) { + if (current.kind === 65) { break; } - else if (current.kind === 156 /* PropertyAccessExpression */) { + else if (current.kind === 156) { current = current.expression; } else { @@ -20513,8 +17021,7 @@ var ts; } } enumType = checkExpression(expression); - // allow references to constant members of other enums - if (!(enumType.symbol && (enumType.symbol.flags & 384 /* Enum */))) { + if (!(enumType.symbol && (enumType.symbol.flags & 384))) { return undefined; } } @@ -20522,15 +17029,13 @@ var ts; return undefined; } var property = getPropertyOfObjectType(enumType, propertyName); - if (!property || !(property.flags & 8 /* EnumMember */)) { + if (!property || !(property.flags & 8)) { return undefined; } var propertyDecl = property.valueDeclaration; - // self references are illegal if (member === propertyDecl) { return undefined; } - // illegal case: forward reference if (!isDefinedBefore(propertyDecl, member)) { return undefined; } @@ -20543,7 +17048,6 @@ var ts; if (!produceDiagnostics) { return; } - // Grammar checking checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); @@ -20554,17 +17058,10 @@ var ts; if (compilerOptions.separateCompilation && enumIsConst && ts.isInAmbientContext(node)) { error(node.name, ts.Diagnostics.Ambient_const_enums_are_not_allowed_when_the_separateCompilation_flag_is_provided); } - // Spec 2014 - Section 9.3: - // It isn't possible for one enum declaration to continue the automatic numbering sequence of another, - // and when an enum type has multiple declarations, only one declaration is permitted to omit a value - // for the first member. - // - // Only perform this check once per symbol var enumSymbol = getSymbolOfNode(node); var firstDeclaration = ts.getDeclarationOfKind(enumSymbol, node.kind); if (node === firstDeclaration) { if (enumSymbol.declarations.length > 1) { - // check that const is placed\omitted on all enum declarations ts.forEach(enumSymbol.declarations, function (decl) { if (ts.isConstEnumDeclaration(decl) !== enumIsConst) { error(decl.name, ts.Diagnostics.Enum_declarations_must_all_be_const_or_non_const); @@ -20573,8 +17070,7 @@ var ts; } var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { - // return true if we hit a violation of the rule, false otherwise - if (declaration.kind !== 205 /* EnumDeclaration */) { + if (declaration.kind !== 205) { return false; } var enumDeclaration = declaration; @@ -20597,8 +17093,8 @@ var ts; var declarations = symbol.declarations; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; - if ((declaration.kind === 202 /* ClassDeclaration */ || - (declaration.kind === 201 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) && + if ((declaration.kind === 202 || + (declaration.kind === 201 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } @@ -20620,9 +17116,8 @@ var ts; } function checkModuleDeclaration(node) { if (produceDiagnostics) { - // Grammar checking if (!checkGrammarDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { - if (!ts.isInAmbientContext(node) && node.name.kind === 8 /* StringLiteral */) { + if (!ts.isInAmbientContext(node) && node.name.kind === 8) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } } @@ -20630,8 +17125,7 @@ var ts; checkCollisionWithRequireExportsInGeneratedCode(node, node.name); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - // The following checks only apply on a non-ambient instantiated module declaration. - if (symbol.flags & 512 /* ValueModule */ + if (symbol.flags & 512 && symbol.declarations.length > 1 && !ts.isInAmbientContext(node) && ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.separateCompilation)) { @@ -20644,16 +17138,13 @@ var ts; error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged); } } - // if the module merges with a class declaration in the same lexical scope, - // we need to track this to ensure the correct emit. - var mergedClass = ts.getDeclarationOfKind(symbol, 202 /* ClassDeclaration */); + var mergedClass = ts.getDeclarationOfKind(symbol, 202); if (mergedClass && inSameLexicalScope(node, mergedClass)) { - getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */; + getNodeLinks(node).flags |= 2048; } } - // Checks for ambient external modules. - if (node.name.kind === 8 /* StringLiteral */) { + if (node.name.kind === 8) { if (!isGlobalSourceFile(node.parent)) { error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules); } @@ -20666,37 +17157,33 @@ var ts; } function getFirstIdentifier(node) { while (true) { - if (node.kind === 127 /* QualifiedName */) { + if (node.kind === 127) { node = node.left; } - else if (node.kind === 156 /* PropertyAccessExpression */) { + else if (node.kind === 156) { node = node.expression; } else { break; } } - ts.Debug.assert(node.kind === 65 /* Identifier */); + ts.Debug.assert(node.kind === 65); return node; } function checkExternalImportOrExportDeclaration(node) { var moduleName = ts.getExternalModuleName(node); - if (!ts.nodeIsMissing(moduleName) && moduleName.kind !== 8 /* StringLiteral */) { + if (!ts.nodeIsMissing(moduleName) && moduleName.kind !== 8) { error(moduleName, ts.Diagnostics.String_literal_expected); return false; } - var inAmbientExternalModule = node.parent.kind === 207 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; - if (node.parent.kind !== 228 /* SourceFile */ && !inAmbientExternalModule) { - error(moduleName, node.kind === 216 /* ExportDeclaration */ ? + var inAmbientExternalModule = node.parent.kind === 207 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 228 && !inAmbientExternalModule) { + error(moduleName, node.kind === 216 ? ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module); return false; } if (inAmbientExternalModule && isExternalModuleNameRelative(moduleName.text)) { - // TypeScript 1.0 spec (April 2013): 12.1.6 - // An ExternalImportDeclaration in an AmbientExternalModuleDeclaration may reference - // other external modules only through top - level external module names. - // Relative external module names are not permitted. error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name); return false; } @@ -20706,11 +17193,11 @@ var ts; var symbol = getSymbolOfNode(node); var target = resolveAlias(symbol); if (target !== unknownSymbol) { - var excludedMeanings = (symbol.flags & 107455 /* Value */ ? 107455 /* Value */ : 0) | - (symbol.flags & 793056 /* Type */ ? 793056 /* Type */ : 0) | - (symbol.flags & 1536 /* Namespace */ ? 1536 /* Namespace */ : 0); + var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | + (symbol.flags & 793056 ? 793056 : 0) | + (symbol.flags & 1536 ? 1536 : 0); if (target.flags & excludedMeanings) { - var message = node.kind === 218 /* ExportSpecifier */ ? + var message = node.kind === 218 ? ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0; error(node, message, symbolToString(symbol)); @@ -20723,7 +17210,7 @@ var ts; checkAliasSymbol(node); } function checkImportDeclaration(node) { - if (!checkGrammarImportDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { + if (!checkGrammarImportDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); } if (checkExternalImportOrExportDeclaration(node)) { @@ -20733,7 +17220,7 @@ var ts; checkImportBinding(importClause); } if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 212) { checkImportBinding(importClause.namedBindings); } else { @@ -20747,48 +17234,43 @@ var ts; checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node); if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) { checkImportBinding(node); - if (node.flags & 1 /* Export */) { + if (node.flags & 1) { markExportAsReferenced(node); } if (ts.isInternalModuleImportEqualsDeclaration(node)) { var target = resolveAlias(getSymbolOfNode(node)); if (target !== unknownSymbol) { - if (target.flags & 107455 /* Value */) { - // Target is a value symbol, check that it is not hidden by a local declaration with the same name + if (target.flags & 107455) { var moduleName = getFirstIdentifier(node.moduleReference); - if (!(resolveEntityName(moduleName, 107455 /* Value */ | 1536 /* Namespace */).flags & 1536 /* Namespace */)) { + if (!(resolveEntityName(moduleName, 107455 | 1536).flags & 1536)) { error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName)); } } - if (target.flags & 793056 /* Type */) { + if (target.flags & 793056) { checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0); } } } else { - if (languageVersion >= 2 /* ES6 */) { - // Import equals declaration is deprecated in es6 or above + if (languageVersion >= 2) { grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_or_import_d_from_mod_instead); } } } } function checkExportDeclaration(node) { - if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); } if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { if (node.exportClause) { - // export { x, y } - // export { x, y } from "foo" ts.forEach(node.exportClause.elements, checkExportSpecifier); - var inAmbientExternalModule = node.parent.kind === 207 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; - if (node.parent.kind !== 228 /* SourceFile */ && !inAmbientExternalModule) { + var inAmbientExternalModule = node.parent.kind === 207 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 228 && !inAmbientExternalModule) { error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace); } } else { - // export * from "foo" var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); if (moduleSymbol && moduleSymbol.exports["export="]) { error(node.moduleSpecifier, ts.Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol)); @@ -20803,16 +17285,15 @@ var ts; } } function checkExportAssignment(node) { - var container = node.parent.kind === 228 /* SourceFile */ ? node.parent : node.parent.parent; - if (container.kind === 206 /* ModuleDeclaration */ && container.name.kind === 65 /* Identifier */) { + var container = node.parent.kind === 228 ? node.parent : node.parent.parent; + if (container.kind === 206 && container.name.kind === 65) { error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace); return; } - // Grammar checking - if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers); } - if (node.expression.kind === 65 /* Identifier */) { + if (node.expression.kind === 65) { markExportAsReferenced(node); } else { @@ -20820,21 +17301,19 @@ var ts; } checkExternalModuleExports(container); if (node.isExportEquals && !ts.isInAmbientContext(node)) { - if (languageVersion >= 2 /* ES6 */) { - // export assignment is deprecated in es6 or above + if (languageVersion >= 2) { grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_export_default_instead); } - else if (compilerOptions.module === 4 /* System */) { - // system modules does not support export assignment + else if (compilerOptions.module === 4) { grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system); } } } function getModuleStatements(node) { - if (node.kind === 228 /* SourceFile */) { + if (node.kind === 228) { return node.statements; } - if (node.kind === 206 /* ModuleDeclaration */ && node.body.kind === 207 /* ModuleBlock */) { + if (node.kind === 206 && node.body.kind === 207) { return node.body.statements; } return emptyArray; @@ -20863,196 +17342,187 @@ var ts; if (!node) return; switch (node.kind) { - case 129 /* TypeParameter */: + case 129: return checkTypeParameter(node); - case 130 /* Parameter */: + case 130: return checkParameter(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 133: + case 132: return checkPropertyDeclaration(node); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: + case 143: + case 144: + case 139: + case 140: return checkSignatureDeclaration(node); - case 141 /* IndexSignature */: + case 141: return checkSignatureDeclaration(node); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: return checkMethodDeclaration(node); - case 136 /* Constructor */: + case 136: return checkConstructorDeclaration(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 137: + case 138: return checkAccessorDeclaration(node); - case 142 /* TypeReference */: + case 142: return checkTypeReferenceNode(node); - case 145 /* TypeQuery */: + case 145: return checkTypeQuery(node); - case 146 /* TypeLiteral */: + case 146: return checkTypeLiteral(node); - case 147 /* ArrayType */: + case 147: return checkArrayType(node); - case 148 /* TupleType */: + case 148: return checkTupleType(node); - case 149 /* UnionType */: + case 149: return checkUnionType(node); - case 150 /* ParenthesizedType */: + case 150: return checkSourceElement(node.type); - case 201 /* FunctionDeclaration */: + case 201: return checkFunctionDeclaration(node); - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 180: + case 207: return checkBlock(node); - case 181 /* VariableStatement */: + case 181: return checkVariableStatement(node); - case 183 /* ExpressionStatement */: + case 183: return checkExpressionStatement(node); - case 184 /* IfStatement */: + case 184: return checkIfStatement(node); - case 185 /* DoStatement */: + case 185: return checkDoStatement(node); - case 186 /* WhileStatement */: + case 186: return checkWhileStatement(node); - case 187 /* ForStatement */: + case 187: return checkForStatement(node); - case 188 /* ForInStatement */: + case 188: return checkForInStatement(node); - case 189 /* ForOfStatement */: + case 189: return checkForOfStatement(node); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 190: + case 191: return checkBreakOrContinueStatement(node); - case 192 /* ReturnStatement */: + case 192: return checkReturnStatement(node); - case 193 /* WithStatement */: + case 193: return checkWithStatement(node); - case 194 /* SwitchStatement */: + case 194: return checkSwitchStatement(node); - case 195 /* LabeledStatement */: + case 195: return checkLabeledStatement(node); - case 196 /* ThrowStatement */: + case 196: return checkThrowStatement(node); - case 197 /* TryStatement */: + case 197: return checkTryStatement(node); - case 199 /* VariableDeclaration */: + case 199: return checkVariableDeclaration(node); - case 153 /* BindingElement */: + case 153: return checkBindingElement(node); - case 202 /* ClassDeclaration */: + case 202: return checkClassDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 203: return checkInterfaceDeclaration(node); - case 204 /* TypeAliasDeclaration */: + case 204: return checkTypeAliasDeclaration(node); - case 205 /* EnumDeclaration */: + case 205: return checkEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 206: return checkModuleDeclaration(node); - case 210 /* ImportDeclaration */: + case 210: return checkImportDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 209: return checkImportEqualsDeclaration(node); - case 216 /* ExportDeclaration */: + case 216: return checkExportDeclaration(node); - case 215 /* ExportAssignment */: + case 215: return checkExportAssignment(node); - case 182 /* EmptyStatement */: + case 182: checkGrammarStatementInAmbientContext(node); return; - case 198 /* DebuggerStatement */: + case 198: checkGrammarStatementInAmbientContext(node); return; - case 219 /* MissingDeclaration */: + case 219: return checkMissingDeclaration(node); } } - // Function expression bodies are checked after all statements in the enclosing body. This is to ensure - // constructs like the following are permitted: - // let foo = function () { - // let s = foo(); - // return "hello"; - // } - // Here, performing a full type check of the body of the function expression whilst in the process of - // determining the type of foo would cause foo to be given type any because of the recursive reference. - // Delaying the type check of the body ensures foo has been assigned a type. function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 163: + case 164: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: + case 136: + case 137: + case 138: + case 201: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 193 /* WithStatement */: + case 193: checkFunctionExpressionBodies(node.expression); break; - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 153 /* BindingElement */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 225 /* PropertyAssignment */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 160 /* TaggedTemplateExpression */: - case 172 /* TemplateExpression */: - case 178 /* TemplateSpan */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 166 /* TypeOfExpression */: - case 167 /* VoidExpression */: - case 165 /* DeleteExpression */: - case 168 /* PrefixUnaryExpression */: - case 169 /* PostfixUnaryExpression */: - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 181 /* VariableStatement */: - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: - case 208 /* CaseBlock */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 196 /* ThrowStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: - case 199 /* VariableDeclaration */: - case 200 /* VariableDeclarationList */: - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 215 /* ExportAssignment */: - case 228 /* SourceFile */: + case 130: + case 133: + case 132: + case 151: + case 152: + case 153: + case 154: + case 155: + case 225: + case 156: + case 157: + case 158: + case 159: + case 160: + case 172: + case 178: + case 161: + case 162: + case 166: + case 167: + case 165: + case 168: + case 169: + case 170: + case 171: + case 174: + case 180: + case 207: + case 181: + case 183: + case 184: + case 185: + case 186: + case 187: + case 188: + case 189: + case 190: + case 191: + case 192: + case 194: + case 208: + case 221: + case 222: + case 195: + case 196: + case 197: + case 224: + case 199: + case 200: + case 202: + case 205: + case 227: + case 215: + case 228: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -21062,11 +17532,9 @@ var ts; checkSourceFileWorker(node); ts.checkTime += new Date().getTime() - start; } - // Fully type check a source file and collect the relevant diagnostics. function checkSourceFileWorker(node) { var links = getNodeLinks(node); - if (!(links.flags & 1 /* TypeChecked */)) { - // Grammar checking + if (!(links.flags & 1)) { checkGrammarSourceFile(node); emitExtends = false; emitDecorate = false; @@ -21082,15 +17550,15 @@ var ts; potentialThisCollisions.length = 0; } if (emitExtends) { - links.flags |= 8 /* EmitExtends */; + links.flags |= 8; } if (emitDecorate) { - links.flags |= 512 /* EmitDecorate */; + links.flags |= 512; } if (emitParam) { - links.flags |= 1024 /* EmitParam */; + links.flags |= 1024; } - links.flags |= 1 /* TypeChecked */; + links.flags |= 1; } } function getDiagnostics(sourceFile) { @@ -21111,11 +17579,10 @@ var ts; throw new Error("Trying to get diagnostics from a type checker that does not produce them."); } } - // Language service support function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 193 /* WithStatement */ && node.parent.statement === node) { + if (node.parent.kind === 193 && node.parent.statement === node) { return true; } node = node.parent; @@ -21127,7 +17594,6 @@ var ts; var symbols = {}; var memberFlags = 0; if (isInsideWithStatementBody(location)) { - // We cannot answer semantic questions within a with block, do not proceed any further return []; } populateSymbols(); @@ -21138,23 +17604,23 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228 /* SourceFile */: + case 228: if (!ts.isExternalModule(location)) { break; } - case 206 /* ModuleDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); + case 206: + copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 205 /* EnumDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); + case 205: + copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - if (!(memberFlags & 128 /* Static */)) { - copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); + case 202: + case 203: + if (!(memberFlags & 128)) { + copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 163 /* FunctionExpression */: + case 163: if (location.name) { copySymbol(location.symbol, meaning); } @@ -21165,7 +17631,6 @@ var ts; } copySymbols(globals, meaning); } - // Returns 'true' if we should stop processing symbols. function copySymbol(symbol, meaning) { if (symbol.flags & meaning) { var id = symbol.name; @@ -21184,7 +17649,6 @@ var ts; } } if (isInsideWithStatementBody(location)) { - // We cannot answer semantic questions within a with block, do not proceed any further return []; } while (location) { @@ -21192,22 +17656,22 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228 /* SourceFile */: + case 228: if (!ts.isExternalModule(location)) break; - case 206 /* ModuleDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); + case 206: + copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 205 /* EnumDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); + case 205: + copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - if (!(memberFlags & 128 /* Static */)) { - copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); + case 202: + case 203: + if (!(memberFlags & 128)) { + copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 163 /* FunctionExpression */: + case 163: if (location.name) { copySymbol(location.symbol, meaning); } @@ -21220,124 +17684,110 @@ var ts; return symbolsToArray(symbols); } function isTypeDeclarationName(name) { - return name.kind == 65 /* Identifier */ && + return name.kind == 65 && isTypeDeclaration(name.parent) && name.parent.name === name; } function isTypeDeclaration(node) { switch (node.kind) { - case 129 /* TypeParameter */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: + case 129: + case 202: + case 203: + case 204: + case 205: return true; } } - // True if the given identifier is part of a type reference function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 127 /* QualifiedName */) { + while (node.parent && node.parent.kind === 127) { node = node.parent; } - return node.parent && node.parent.kind === 142 /* TypeReference */; + return node.parent && node.parent.kind === 142; } function isHeritageClauseElementIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 156 /* PropertyAccessExpression */) { + while (node.parent && node.parent.kind === 156) { node = node.parent; } - return node.parent && node.parent.kind === 177 /* ExpressionWithTypeArguments */; + return node.parent && node.parent.kind === 177; } function isTypeNode(node) { - if (142 /* FirstTypeNode */ <= node.kind && node.kind <= 150 /* LastTypeNode */) { + if (142 <= node.kind && node.kind <= 150) { return true; } switch (node.kind) { - case 112 /* AnyKeyword */: - case 120 /* NumberKeyword */: - case 122 /* StringKeyword */: - case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 112: + case 120: + case 122: + case 113: + case 123: return true; - case 99 /* VoidKeyword */: - return node.parent.kind !== 167 /* VoidExpression */; - case 8 /* StringLiteral */: - // Specialized signatures can have string literals as their parameters' type names - return node.parent.kind === 130 /* Parameter */; - case 177 /* ExpressionWithTypeArguments */: + case 99: + return node.parent.kind !== 167; + case 8: + return node.parent.kind === 130; + case 177: return true; - // Identifiers and qualified names may be type nodes, depending on their context. Climb - // above them to find the lowest container - case 65 /* Identifier */: - // If the identifier is the RHS of a qualified name, then it's a type iff its parent is. - if (node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node) { + case 65: + if (node.parent.kind === 127 && node.parent.right === node) { node = node.parent; } - else if (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node) { + else if (node.parent.kind === 156 && node.parent.name === node) { node = node.parent; } - // fall through - case 127 /* QualifiedName */: - case 156 /* PropertyAccessExpression */: - // At this point, node is either a qualified name or an identifier - ts.Debug.assert(node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */ || node.kind === 156 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); + case 127: + case 156: + ts.Debug.assert(node.kind === 65 || node.kind === 127 || node.kind === 156, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); var parent_5 = node.parent; - if (parent_5.kind === 145 /* TypeQuery */) { + if (parent_5.kind === 145) { return false; } - // Do not recursively call isTypeNode on the parent. In the example: - // - // let a: A.B.C; - // - // Calling isTypeNode would consider the qualified name A.B a type node. Only C or - // A.B.C is a type node. - if (142 /* FirstTypeNode */ <= parent_5.kind && parent_5.kind <= 150 /* LastTypeNode */) { + if (142 <= parent_5.kind && parent_5.kind <= 150) { return true; } switch (parent_5.kind) { - case 177 /* ExpressionWithTypeArguments */: + case 177: return true; - case 129 /* TypeParameter */: + case 129: return node === parent_5.constraint; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: + case 133: + case 132: + case 130: + case 199: return node === parent_5.type; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 136 /* Constructor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 201: + case 163: + case 164: + case 136: + case 135: + case 134: + case 137: + case 138: return node === parent_5.type; - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 139: + case 140: + case 141: return node === parent_5.type; - case 161 /* TypeAssertionExpression */: + case 161: return node === parent_5.type; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 158: + case 159: return parent_5.typeArguments && ts.indexOf(parent_5.typeArguments, node) >= 0; - case 160 /* TaggedTemplateExpression */: - // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments. + case 160: return false; } } return false; } function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 127 /* QualifiedName */) { + while (nodeOnRightSide.parent.kind === 127) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 209 /* ImportEqualsDeclaration */) { + if (nodeOnRightSide.parent.kind === 209) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 215 /* ExportAssignment */) { + if (nodeOnRightSide.parent.kind === 215) { return nodeOnRightSide.parent.expression === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; @@ -21349,13 +17799,11 @@ var ts; if (ts.isDeclarationName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 215 /* ExportAssignment */) { - return resolveEntityName(entityName, - /*all meanings*/ 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */); + if (entityName.parent.kind === 215) { + return resolveEntityName(entityName, 107455 | 793056 | 1536 | 8388608); } - if (entityName.kind !== 156 /* PropertyAccessExpression */) { + if (entityName.kind !== 156) { if (isInRightSideOfImportOrExportAssignment(entityName)) { - // Since we already checked for ExportAssignment, this really could only be an Import return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); } } @@ -21363,29 +17811,26 @@ var ts; entityName = entityName.parent; } if (isHeritageClauseElementIdentifier(entityName)) { - var meaning = entityName.parent.kind === 177 /* ExpressionWithTypeArguments */ ? 793056 /* Type */ : 1536 /* Namespace */; - meaning |= 8388608 /* Alias */; + var meaning = entityName.parent.kind === 177 ? 793056 : 1536; + meaning |= 8388608; return resolveEntityName(entityName, meaning); } else if (ts.isExpression(entityName)) { if (ts.nodeIsMissing(entityName)) { - // Missing entity name. return undefined; } - if (entityName.kind === 65 /* Identifier */) { - // Include aliases in the meaning, this ensures that we do not follow aliases to where they point and instead - // return the alias symbol. - var meaning = 107455 /* Value */ | 8388608 /* Alias */; + if (entityName.kind === 65) { + var meaning = 107455 | 8388608; return resolveEntityName(entityName, meaning); } - else if (entityName.kind === 156 /* PropertyAccessExpression */) { + else if (entityName.kind === 156) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 127 /* QualifiedName */) { + else if (entityName.kind === 127) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -21394,58 +17839,49 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 142 /* TypeReference */ ? 793056 /* Type */ : 1536 /* Namespace */; - // Include aliases in the meaning, this ensures that we do not follow aliases to where they point and instead - // return the alias symbol. - meaning |= 8388608 /* Alias */; + var meaning = entityName.parent.kind === 142 ? 793056 : 1536; + meaning |= 8388608; return resolveEntityName(entityName, meaning); } - // Do we want to return undefined here? return undefined; } function getSymbolInfo(node) { if (isInsideWithStatementBody(node)) { - // We cannot answer semantic questions within a with block, do not proceed any further return undefined; } if (ts.isDeclarationName(node)) { - // This is a declaration, call getSymbolOfNode return getSymbolOfNode(node.parent); } - if (node.kind === 65 /* Identifier */ && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 215 /* ExportAssignment */ + if (node.kind === 65 && isInRightSideOfImportOrExportAssignment(node)) { + return node.parent.kind === 215 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { - case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: + case 65: + case 156: + case 127: return getSymbolOfEntityNameOrPropertyAccessExpression(node); - case 93 /* ThisKeyword */: - case 91 /* SuperKeyword */: + case 93: + case 91: var type = checkExpression(node); return type.symbol; - case 114 /* ConstructorKeyword */: - // constructor keyword for an overload, should take us to the definition if it exist + case 114: var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 136 /* Constructor */) { + if (constructorDeclaration && constructorDeclaration.kind === 136) { return constructorDeclaration.parent.symbol; } return undefined; - case 8 /* StringLiteral */: - // External module name in an import declaration + case 8: var moduleName; if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || - ((node.parent.kind === 210 /* ImportDeclaration */ || node.parent.kind === 216 /* ExportDeclaration */) && + ((node.parent.kind === 210 || node.parent.kind === 216) && node.parent.moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } - // Intentional fall-through - case 7 /* NumericLiteral */: - // index access - if (node.parent.kind == 157 /* ElementAccessExpression */ && node.parent.argumentExpression === node) { + case 7: + if (node.parent.kind == 157 && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -21459,17 +17895,13 @@ var ts; return undefined; } function getShorthandAssignmentValueSymbol(location) { - // The function returns a value symbol of an identifier in the short-hand property assignment. - // This is necessary as an identifier in short-hand property assignment can contains two meaning: - // property name and property value. - if (location && location.kind === 226 /* ShorthandPropertyAssignment */) { - return resolveEntityName(location.name, 107455 /* Value */); + if (location && location.kind === 226) { + return resolveEntityName(location.name, 107455); } return undefined; } function getTypeOfNode(node) { if (isInsideWithStatementBody(node)) { - // We cannot answer semantic questions within a with block, do not proceed any further return unknownType; } if (isTypeNode(node)) { @@ -21479,7 +17911,6 @@ var ts; return getTypeOfExpression(node); } if (isTypeDeclaration(node)) { - // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration var symbol = getSymbolOfNode(node); return getDeclaredTypeOfSymbol(symbol); } @@ -21488,7 +17919,6 @@ var ts; return symbol && getDeclaredTypeOfSymbol(symbol); } if (ts.isDeclaration(node)) { - // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration var symbol = getSymbolOfNode(node); return getTypeOfSymbol(symbol); } @@ -21509,12 +17939,10 @@ var ts; } return checkExpression(expr); } - // Return the list of properties of the given type, augmented with properties from Function - // if the type has call or construct signatures function getAugmentedPropertiesOfType(type) { type = getApparentType(type); var propsByName = createSymbolTable(getPropertiesOfType(type)); - if (getSignaturesOfType(type, 0 /* Call */).length || getSignaturesOfType(type, 1 /* Construct */).length) { + if (getSignaturesOfType(type, 0).length || getSignaturesOfType(type, 1).length) { ts.forEach(getPropertiesOfType(globalFunctionType), function (p) { if (!ts.hasProperty(propsByName, p.name)) { propsByName[p.name] = p; @@ -21524,7 +17952,7 @@ var ts; return getNamedMembers(propsByName); } function getRootSymbols(symbol) { - if (symbol.flags & 268435456 /* UnionProperty */) { + if (symbol.flags & 268435456) { var symbols = []; var name_10 = symbol.name; ts.forEach(getSymbolLinks(symbol).unionType.types, function (t) { @@ -21532,7 +17960,7 @@ var ts; }); return symbols; } - else if (symbol.flags & 67108864 /* Transient */) { + else if (symbol.flags & 67108864) { var target = getSymbolLinks(symbol).target; if (target) { return [target]; @@ -21540,21 +17968,18 @@ var ts; } return [symbol]; } - // Emitter support function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 /* ValueModule */ && symbol.declarations.length === 1 && symbol.declarations[0].kind === 228 /* SourceFile */; + return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 228; } function getAliasNameSubstitution(symbol, getGeneratedNameForNode) { - // If this is es6 or higher, just use the name of the export - // no need to qualify it. - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { return undefined; } var node = getDeclarationOfAliasSymbol(symbol); if (node) { - if (node.kind === 211 /* ImportClause */) { + if (node.kind === 211) { var defaultKeyword; - if (languageVersion === 0 /* ES3 */) { + if (languageVersion === 0) { defaultKeyword = "[\"default\"]"; } else { @@ -21562,7 +17987,7 @@ var ts; } return getGeneratedNameForNode(node.parent) + defaultKeyword; } - if (node.kind === 214 /* ImportSpecifier */) { + if (node.kind === 214) { var moduleName = getGeneratedNameForNode(node.parent.parent.parent); var propertyName = node.propertyName || node.name; return moduleName + "." + ts.unescapeIdentifier(propertyName.text); @@ -21571,11 +17996,7 @@ var ts; } function getExportNameSubstitution(symbol, location, getGeneratedNameForNode) { if (isExternalModuleSymbol(symbol.parent)) { - // 1. If this is es6 or higher, just use the name of the export - // no need to qualify it. - // 2. export mechanism for System modules is different from CJS\AMD - // and it does not need qualifications for exports - if (languageVersion >= 2 /* ES6 */ || compilerOptions.module === 4 /* System */) { + if (languageVersion >= 2 || compilerOptions.module === 4) { return undefined; } return "exports." + ts.unescapeIdentifier(symbol.name); @@ -21583,7 +18004,7 @@ var ts; var node = location; var containerSymbol = getParentOfSymbol(symbol); while (node) { - if ((node.kind === 206 /* ModuleDeclaration */ || node.kind === 205 /* EnumDeclaration */) && getSymbolOfNode(node) === containerSymbol) { + if ((node.kind === 206 || node.kind === 205) && getSymbolOfNode(node) === containerSymbol) { return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); } node = node.parent; @@ -21592,43 +18013,36 @@ var ts; function getExpressionNameSubstitution(node, getGeneratedNameForNode) { var symbol = getNodeLinks(node).resolvedSymbol || (ts.isDeclarationName(node) ? getSymbolOfNode(node.parent) : undefined); if (symbol) { - // Whan an identifier resolves to a parented symbol, it references an exported entity from - // another declaration of the same internal module. if (symbol.parent) { return getExportNameSubstitution(symbol, node.parent, getGeneratedNameForNode); } - // If we reference an exported entity within the same module declaration, then whether - // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the - // kinds that we do NOT prefix. var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); - if (symbol !== exportSymbol && !(exportSymbol.flags & 944 /* ExportHasLocal */)) { + if (symbol !== exportSymbol && !(exportSymbol.flags & 944)) { return getExportNameSubstitution(exportSymbol, node.parent, getGeneratedNameForNode); } - // Named imports from ES6 import declarations are rewritten - if (symbol.flags & 8388608 /* Alias */) { + if (symbol.flags & 8388608) { return getAliasNameSubstitution(symbol, getGeneratedNameForNode); } } } function isValueAliasDeclaration(node) { switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 209: + case 211: + case 212: + case 214: + case 218: return isAliasResolvedToValue(getSymbolOfNode(node)); - case 216 /* ExportDeclaration */: + case 216: var exportClause = node.exportClause; return exportClause && ts.forEach(exportClause.elements, isValueAliasDeclaration); - case 215 /* ExportAssignment */: - return node.expression && node.expression.kind === 65 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfNode(node)) : true; + case 215: + return node.expression && node.expression.kind === 65 ? isAliasResolvedToValue(getSymbolOfNode(node)) : true; } return false; } function isTopLevelValueImportEqualsWithEntityName(node) { - if (node.parent.kind !== 228 /* SourceFile */ || !ts.isInternalModuleImportEqualsDeclaration(node)) { - // parent is not source file or it is not reference to internal module + if (node.parent.kind !== 228 || !ts.isInternalModuleImportEqualsDeclaration(node)) { return false; } var isValue = isAliasResolvedToValue(getSymbolOfNode(node)); @@ -21639,8 +18053,7 @@ var ts; if (target === unknownSymbol && compilerOptions.separateCompilation) { return true; } - // const enums and modules that contain only const enums are not considered values from the emit perespective - return target !== unknownSymbol && target && target.flags & 107455 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target); + return target !== unknownSymbol && target && target.flags & 107455 && !isConstEnumOrConstEnumOnlyModule(target); } function isConstEnumOrConstEnumOnlyModule(s) { return isConstEnumSymbol(s) || s.constEnumOnlyModule; @@ -21661,18 +18074,7 @@ var ts; if (ts.nodeIsPresent(node.body)) { var symbol = getSymbolOfNode(node); var signaturesOfSymbol = getSignaturesOfSymbol(symbol); - // If this function body corresponds to function with multiple signature, it is implementation of overload - // e.g.: function foo(a: string): string; - // function foo(a: number): number; - // function foo(a: any) { // This is implementation of the overloads - // return a; - // } return signaturesOfSymbol.length > 1 || - // If there is single signature for the symbol, it is overload if that signature isn't coming from the node - // e.g.: function foo(a: string): string; - // function foo(a: any) { // This is implementation of the overloads - // return a; - // } (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node); } return false; @@ -21685,21 +18087,19 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 227 /* EnumMember */) { + if (node.kind === 227) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; - if (symbol && (symbol.flags & 8 /* EnumMember */)) { - // inline property\index accesses only for const enums + if (symbol && (symbol.flags & 8)) { if (ts.isConstEnumDeclaration(symbol.valueDeclaration.parent)) { return getEnumMemberValue(symbol.valueDeclaration); } } return undefined; } - /** Serializes an EntityName (with substitutions) to an appropriate JS constructor value. Used by the __metadata decorator. */ function serializeEntityName(node, getGeneratedNameForNode, fallbackPath) { - if (node.kind === 65 /* Identifier */) { + if (node.kind === 65) { var substitution = getExpressionNameSubstitution(node, getGeneratedNameForNode); var text = substitution || node.text; if (fallbackPath) { @@ -21717,36 +18117,24 @@ var ts; } } } - /** Serializes a TypeReferenceNode to an appropriate JS constructor value. Used by the __metadata decorator. */ function serializeTypeReferenceNode(node, getGeneratedNameForNode) { - // serialization of a TypeReferenceNode uses the following rules: - // - // * The serialized type of a TypeReference that is `void` is "void 0". - // * The serialized type of a TypeReference that is a `boolean` is "Boolean". - // * The serialized type of a TypeReference that is an enum or `number` is "Number". - // * The serialized type of a TypeReference that is a string literal or `string` is "String". - // * The serialized type of a TypeReference that is a tuple is "Array". - // * The serialized type of a TypeReference that is a `symbol` is "Symbol". - // * The serialized type of a TypeReference with a value declaration is its entity name. - // * The serialized type of a TypeReference with a call or construct signature is "Function". - // * The serialized type of any other type is "Object". var type = getTypeFromTypeNode(node); - if (type.flags & 16 /* Void */) { + if (type.flags & 16) { return "void 0"; } - else if (type.flags & 8 /* Boolean */) { + else if (type.flags & 8) { return "Boolean"; } - else if (type.flags & 132 /* NumberLike */) { + else if (type.flags & 132) { return "Number"; } - else if (type.flags & 258 /* StringLike */) { + else if (type.flags & 258) { return "String"; } - else if (type.flags & 8192 /* Tuple */) { + else if (type.flags & 8192) { return "Array"; } - else if (type.flags & 1048576 /* ESSymbol */) { + else if (type.flags & 1048576) { return "Symbol"; } else if (type === unknownType) { @@ -21762,43 +18150,32 @@ var ts; } return "Object"; } - /** Serializes a TypeNode to an appropriate JS constructor value. Used by the __metadata decorator. */ function serializeTypeNode(node, getGeneratedNameForNode) { - // serialization of a TypeNode uses the following rules: - // - // * The serialized type of `void` is "void 0" (undefined). - // * The serialized type of a parenthesized type is the serialized type of its nested type. - // * The serialized type of a Function or Constructor type is "Function". - // * The serialized type of an Array or Tuple type is "Array". - // * The serialized type of `boolean` is "Boolean". - // * The serialized type of `string` or a string-literal type is "String". - // * The serialized type of a type reference is handled by `serializeTypeReferenceNode`. - // * The serialized type of any other type node is "Object". if (node) { switch (node.kind) { - case 99 /* VoidKeyword */: + case 99: return "void 0"; - case 150 /* ParenthesizedType */: + case 150: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 143: + case 144: return "Function"; - case 147 /* ArrayType */: - case 148 /* TupleType */: + case 147: + case 148: return "Array"; - case 113 /* BooleanKeyword */: + case 113: return "Boolean"; - case 122 /* StringKeyword */: - case 8 /* StringLiteral */: + case 122: + case 8: return "String"; - case 120 /* NumberKeyword */: + case 120: return "Number"; - case 142 /* TypeReference */: + case 142: return serializeTypeReferenceNode(node, getGeneratedNameForNode); - case 145 /* TypeQuery */: - case 146 /* TypeLiteral */: - case 149 /* UnionType */: - case 112 /* AnyKeyword */: + case 145: + case 146: + case 149: + case 112: break; default: ts.Debug.fail("Cannot serialize unexpected type node."); @@ -21807,41 +18184,23 @@ var ts; } return "Object"; } - /** Serializes the type of a declaration to an appropriate JS constructor value. Used by the __metadata decorator for a class member. */ function serializeTypeOfNode(node, getGeneratedNameForNode) { - // serialization of the type of a declaration uses the following rules: - // - // * The serialized type of a ClassDeclaration is "Function" - // * The serialized type of a ParameterDeclaration is the serialized type of its type annotation. - // * The serialized type of a PropertyDeclaration is the serialized type of its type annotation. - // * The serialized type of an AccessorDeclaration is the serialized type of the return type annotation of its getter or parameter type annotation of its setter. - // * The serialized type of any other FunctionLikeDeclaration is "Function". - // * The serialized type of any other node is "void 0". - // - // For rules on serializing type annotations, see `serializeTypeNode`. switch (node.kind) { - case 202 /* ClassDeclaration */: return "Function"; - case 133 /* PropertyDeclaration */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 130 /* Parameter */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 137 /* GetAccessor */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 138 /* SetAccessor */: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node), getGeneratedNameForNode); + case 202: return "Function"; + case 133: return serializeTypeNode(node.type, getGeneratedNameForNode); + case 130: return serializeTypeNode(node.type, getGeneratedNameForNode); + case 137: return serializeTypeNode(node.type, getGeneratedNameForNode); + case 138: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node), getGeneratedNameForNode); } if (ts.isFunctionLike(node)) { return "Function"; } return "void 0"; } - /** Serializes the parameter types of a function or the constructor of a class. Used by the __metadata decorator for a method or set accessor. */ function serializeParameterTypesOfNode(node, getGeneratedNameForNode) { - // serialization of parameter types uses the following rules: - // - // * If the declaration is a class, the parameters of the first constructor with a body are used. - // * If the declaration is function-like and has a body, the parameters of the function are used. - // - // For the rules on serializing the type of each parameter declaration, see `serializeTypeOfDeclaration`. if (node) { var valueDeclaration; - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 202) { valueDeclaration = ts.getFirstConstructorWithBody(node); } else if (ts.isFunctionLike(node) && ts.nodeIsPresent(node.body)) { @@ -21856,10 +18215,10 @@ var ts; for (var i = 0; i < parameterCount; i++) { if (parameters[i].dotDotDotToken) { var parameterType = parameters[i].type; - if (parameterType.kind === 147 /* ArrayType */) { + if (parameterType.kind === 147) { parameterType = parameterType.elementType; } - else if (parameterType.kind === 142 /* TypeReference */ && parameterType.typeArguments && parameterType.typeArguments.length === 1) { + else if (parameterType.kind === 142 && parameterType.typeArguments && parameterType.typeArguments.length === 1) { parameterType = parameterType.typeArguments[0]; } else { @@ -21877,7 +18236,6 @@ var ts; } return emptyArray; } - /** Serializes the return type of function. Used by the __metadata decorator for a method. */ function serializeReturnTypeOfNode(node, getGeneratedNameForNode) { if (node && ts.isFunctionLike(node)) { return serializeTypeNode(node.type, getGeneratedNameForNode); @@ -21885,9 +18243,8 @@ var ts; return "void 0"; } function writeTypeOfDeclaration(declaration, enclosingDeclaration, flags, writer) { - // Get type of the symbol if this is the valid symbol otherwise get type at location var symbol = getSymbolOfNode(declaration); - var type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) + var type = symbol && !(symbol.flags & (2048 | 131072)) ? getTypeOfSymbol(symbol) : unknownType; getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); @@ -21905,26 +18262,24 @@ var ts; } function resolvesToSomeValue(location, name) { ts.Debug.assert(!ts.nodeIsSynthesized(location), "resolvesToSomeValue called with a synthesized location"); - return !!resolveName(location, name, 107455 /* Value */, undefined, undefined); + return !!resolveName(location, name, 107455, undefined, undefined); } function getReferencedValueDeclaration(reference) { ts.Debug.assert(!ts.nodeIsSynthesized(reference)); var symbol = getNodeLinks(reference).resolvedSymbol || - resolveName(reference, reference.text, 107455 /* Value */ | 8388608 /* Alias */, undefined, undefined); + resolveName(reference, reference.text, 107455 | 8388608, undefined, undefined); return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; } function getBlockScopedVariableId(n) { ts.Debug.assert(!ts.nodeIsSynthesized(n)); - var isVariableDeclarationOrBindingElement = n.parent.kind === 153 /* BindingElement */ || (n.parent.kind === 199 /* VariableDeclaration */ && n.parent.name === n); + var isVariableDeclarationOrBindingElement = n.parent.kind === 153 || (n.parent.kind === 199 && n.parent.name === n); var symbol = (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || getNodeLinks(n).resolvedSymbol || - resolveName(n, n.text, 107455 /* Value */ | 8388608 /* Alias */, undefined, undefined); + resolveName(n, n.text, 107455 | 8388608, undefined, undefined); var isLetOrConst = symbol && - (symbol.flags & 2 /* BlockScopedVariable */) && - symbol.valueDeclaration.parent.kind !== 224 /* CatchClause */; + (symbol.flags & 2) && + symbol.valueDeclaration.parent.kind !== 224; if (isLetOrConst) { - // side-effect of calling this method: - // assign id to symbol if it was not yet set getSymbolLinks(symbol); return symbol.id; } @@ -21967,22 +18322,18 @@ var ts; }; } function initializeTypeChecker() { - // Bind all source files and propagate errors ts.forEach(host.getSourceFiles(), function (file) { ts.bindSourceFile(file); }); - // Initialize global symbol table ts.forEach(host.getSourceFiles(), function (file) { if (!ts.isExternalModule(file)) { mergeSymbolTable(globals, file.locals); } }); - // Initialize special symbols getSymbolLinks(undefinedSymbol).type = undefinedType; getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments"); getSymbolLinks(unknownSymbol).type = unknownType; globals[undefinedSymbol.name] = undefinedSymbol; - // Initialize special types globalArraySymbol = getGlobalTypeSymbol("Array"); globalArrayType = getTypeOfGlobalSymbol(globalArraySymbol, 1); globalObjectType = getGlobalType("Object"); @@ -21995,9 +18346,7 @@ var ts; getGlobalPropertyDecoratorType = ts.memoize(function () { return getGlobalType("PropertyDecorator"); }); getGlobalMethodDecoratorType = ts.memoize(function () { return getGlobalType("MethodDecorator"); }); getGlobalParameterDecoratorType = ts.memoize(function () { return getGlobalType("ParameterDecorator"); }); - // If we're in ES6 mode, load the TemplateStringsArray. - // Otherwise, default to 'unknown' for the purposes of type checking in LS scenarios. - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { globalTemplateStringsArrayType = getGlobalType("TemplateStringsArray"); globalESSymbolType = getGlobalType("Symbol"); globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol"); @@ -22005,42 +18354,34 @@ var ts; } else { globalTemplateStringsArrayType = unknownType; - // Consider putting Symbol interface in lib.d.ts. On the plus side, putting it in lib.d.ts would make it - // extensible for Polyfilling Symbols. But putting it into lib.d.ts could also break users that have - // a global Symbol already, particularly if it is a class. globalESSymbolType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); globalESSymbolConstructorSymbol = undefined; } anyArrayType = createArrayType(anyType); } - // GRAMMAR CHECKING function isReservedWordInStrictMode(node) { - // Check that originalKeywordKind is less than LastFutureReservedWord to see if an Identifier is a strict-mode reserved word - return (node.parserContextFlags & 1 /* StrictMode */) && - (102 /* FirstFutureReservedWord */ <= node.originalKeywordKind && node.originalKeywordKind <= 110 /* LastFutureReservedWord */); + return (node.parserContextFlags & 1) && + (102 <= node.originalKeywordKind && node.originalKeywordKind <= 110); } function reportStrictModeGrammarErrorInClassDeclaration(identifier, message, arg0, arg1, arg2) { - // We are checking if this name is inside class declaration or class expression (which are under class definitions inside ES6 spec.) - // if so, we would like to give more explicit invalid usage error. - if (ts.getAncestor(identifier, 202 /* ClassDeclaration */) || ts.getAncestor(identifier, 175 /* ClassExpression */)) { + if (ts.getAncestor(identifier, 202) || ts.getAncestor(identifier, 175)) { return grammarErrorOnNode(identifier, message, arg0); } return false; } function checkGrammarImportDeclarationNameInStrictMode(node) { - // Check if the import declaration used strict-mode reserved word in its names bindings if (node.importClause) { var impotClause = node.importClause; if (impotClause.namedBindings) { var nameBindings = impotClause.namedBindings; - if (nameBindings.kind === 212 /* NamespaceImport */) { + if (nameBindings.kind === 212) { var name_11 = nameBindings.name; if (isReservedWordInStrictMode(name_11)) { var nameText = ts.declarationNameToString(name_11); return grammarErrorOnNode(name_11, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); } } - else if (nameBindings.kind === 213 /* NamedImports */) { + else if (nameBindings.kind === 213) { var reportError = false; for (var _i = 0, _a = nameBindings.elements; _i < _a.length; _i++) { var element = _a[_i]; @@ -22058,87 +18399,59 @@ var ts; } function checkGrammarDeclarationNameInStrictMode(node) { var name = node.name; - if (name && name.kind === 65 /* Identifier */ && isReservedWordInStrictMode(name)) { + if (name && name.kind === 65 && isReservedWordInStrictMode(name)) { var nameText = ts.declarationNameToString(name); switch (node.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 201 /* FunctionDeclaration */: - case 129 /* TypeParameter */: - case 153 /* BindingElement */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: + case 130: + case 199: + case 201: + case 129: + case 153: + case 203: + case 204: + case 205: return checkGrammarIdentifierInStrictMode(name); - case 202 /* ClassDeclaration */: - // Report an error if the class declaration uses strict-mode reserved word. + case 202: return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText); - case 206 /* ModuleDeclaration */: - // Report an error if the module declaration uses strict-mode reserved word. - // TODO(yuisu): fix this when having external module in strict mode + case 206: return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - case 209 /* ImportEqualsDeclaration */: - // TODO(yuisu): fix this when having external module in strict mode + case 209: return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); } } return false; } function checkGrammarTypeReferenceInStrictMode(typeName) { - // Check if the type reference is using strict mode keyword - // Example: - // class C { - // foo(x: public){} // Error. - // } - if (typeName.kind === 65 /* Identifier */) { + if (typeName.kind === 65) { checkGrammarTypeNameInStrictMode(typeName); } - else if (typeName.kind === 127 /* QualifiedName */) { - // Walk from right to left and report a possible error at each Identifier in QualifiedName - // Example: - // x1: public.private.package // error at public and private + else if (typeName.kind === 127) { checkGrammarTypeNameInStrictMode(typeName.right); checkGrammarTypeReferenceInStrictMode(typeName.left); } } - // This function will report an error for every identifier in property access expression - // whether it violates strict mode reserved words. - // Example: - // public // error at public - // public.private.package // error at public - // B.private.B // no error function checkGrammarExpressionWithTypeArgumentsInStrictMode(expression) { - // Example: - // class C extends public // error at public - if (expression && expression.kind === 65 /* Identifier */) { + if (expression && expression.kind === 65) { return checkGrammarIdentifierInStrictMode(expression); } - else if (expression && expression.kind === 156 /* PropertyAccessExpression */) { - // Walk from left to right in PropertyAccessExpression until we are at the left most expression - // in PropertyAccessExpression. According to grammar production of MemberExpression, - // the left component expression is a PrimaryExpression (i.e. Identifier) while the other - // component after dots can be IdentifierName. + else if (expression && expression.kind === 156) { checkGrammarExpressionWithTypeArgumentsInStrictMode(expression.expression); } } - // The function takes an identifier itself or an expression which has SyntaxKind.Identifier. function checkGrammarIdentifierInStrictMode(node, nameText) { - if (node && node.kind === 65 /* Identifier */ && isReservedWordInStrictMode(node)) { + if (node && node.kind === 65 && isReservedWordInStrictMode(node)) { if (!nameText) { nameText = ts.declarationNameToString(node); } - // TODO (yuisu): Fix when module is a strict mode var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || grammarErrorOnNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); return errorReport; } return false; } - // The function takes an identifier when uses as a typeName in TypeReferenceNode function checkGrammarTypeNameInStrictMode(node) { - if (node && node.kind === 65 /* Identifier */ && isReservedWordInStrictMode(node)) { + if (node && node.kind === 65 && isReservedWordInStrictMode(node)) { var nameText = ts.declarationNameToString(node); - // TODO (yuisu): Fix when module is a strict mode var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || grammarErrorOnNode(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode, nameText); return errorReport; @@ -22152,10 +18465,10 @@ var ts; if (!ts.nodeCanBeDecorated(node)) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_not_valid_here); } - else if (languageVersion < 1 /* ES5 */) { + else if (languageVersion < 1) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher); } - else if (node.kind === 137 /* GetAccessor */ || node.kind === 138 /* SetAccessor */) { + else if (node.kind === 137 || node.kind === 138) { var accessors = ts.getAllAccessorDeclarations(node.parent.members, node); if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); @@ -22165,26 +18478,26 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - case 181 /* VariableStatement */: - case 201 /* FunctionDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 216 /* ExportDeclaration */: - case 215 /* ExportAssignment */: - case 130 /* Parameter */: + case 137: + case 138: + case 136: + case 133: + case 132: + case 135: + case 134: + case 141: + case 202: + case 203: + case 206: + case 205: + case 181: + case 201: + case 204: + case 210: + case 209: + case 216: + case 215: + case 130: break; default: return false; @@ -22197,14 +18510,14 @@ var ts; for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { var modifier = _a[_i]; switch (modifier.kind) { - case 108 /* PublicKeyword */: - case 107 /* ProtectedKeyword */: - case 106 /* PrivateKeyword */: + case 108: + case 107: + case 106: var text = void 0; - if (modifier.kind === 108 /* PublicKeyword */) { + if (modifier.kind === 108) { text = "public"; } - else if (modifier.kind === 107 /* ProtectedKeyword */) { + else if (modifier.kind === 107) { text = "protected"; lastProtected = modifier; } @@ -22212,81 +18525,81 @@ var ts; text = "private"; lastPrivate = modifier; } - if (flags & 112 /* AccessibilityModifier */) { + if (flags & 112) { return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen); } - else if (flags & 128 /* Static */) { + else if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + else if (node.parent.kind === 207 || node.parent.kind === 228) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); break; - case 109 /* StaticKeyword */: - if (flags & 128 /* Static */) { + case 109: + if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + else if (node.parent.kind === 207 || node.parent.kind === 228) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 130) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } - flags |= 128 /* Static */; + flags |= 128; lastStatic = modifier; break; - case 78 /* ExportKeyword */: - if (flags & 1 /* Export */) { + case 78: + if (flags & 1) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export"); } - else if (flags & 2 /* Ambient */) { + else if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 202) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 130) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } - flags |= 1 /* Export */; + flags |= 1; break; - case 115 /* DeclareKeyword */: - if (flags & 2 /* Ambient */) { + case 115: + if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 202) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 130) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 207 /* ModuleBlock */) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 207) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } - flags |= 2 /* Ambient */; + flags |= 2; lastDeclare = modifier; break; } } - if (node.kind === 136 /* Constructor */) { - if (flags & 128 /* Static */) { + if (node.kind === 136) { + if (flags & 128) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } - else if (flags & 64 /* Protected */) { + else if (flags & 64) { return grammarErrorOnNode(lastProtected, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected"); } - else if (flags & 32 /* Private */) { + else if (flags & 32) { return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if ((node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) { + else if ((node.kind === 210 || node.kind === 209) && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 203 /* InterfaceDeclaration */ && flags & 2 /* Ambient */) { + else if (node.kind === 203 && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare"); } - else if (node.kind === 130 /* Parameter */ && (flags & 112 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) { + else if (node.kind === 130 && (flags & 112) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -22344,13 +18657,12 @@ var ts; } } function checkGrammarFunctionLikeDeclaration(node) { - // Prevent cascading error by short-circuit var file = ts.getSourceFileOfNode(node); return checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarTypeParameterList(node, node.typeParameters, file) || checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file); } function checkGrammarArrowFunction(node, file) { - if (node.kind === 164 /* ArrowFunction */) { + if (node.kind === 164) { var arrowFunction = node; var startLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line; var endLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line; @@ -22373,7 +18685,7 @@ var ts; if (parameter.dotDotDotToken) { return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter); } - if (parameter.flags & 499 /* Modifier */) { + if (parameter.flags & 499) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier); } if (parameter.questionToken) { @@ -22385,7 +18697,7 @@ var ts; if (!parameter.type) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); } - if (parameter.type.kind !== 122 /* StringKeyword */ && parameter.type.kind !== 120 /* NumberKeyword */) { + if (parameter.type.kind !== 122 && parameter.type.kind !== 120) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -22393,12 +18705,11 @@ var ts; } } function checkGrammarForIndexSignatureModifier(node) { - if (node.flags & 499 /* Modifier */) { + if (node.flags & 499) { grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_not_permitted_on_index_signature_members); } } function checkGrammarIndexSignature(node) { - // Prevent cascading error by short-circuit return checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarIndexSignatureParameters(node) || checkGrammarForIndexSignatureModifier(node); } function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) { @@ -22418,7 +18729,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var _i = 0; _i < arguments.length; _i++) { var arg = arguments[_i]; - if (arg.kind === 176 /* OmittedExpression */) { + if (arg.kind === 176) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -22445,7 +18756,7 @@ var ts; if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && node.heritageClauses) { for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) { var heritageClause = _a[_i]; - if (heritageClause.token === 79 /* ExtendsKeyword */) { + if (heritageClause.token === 79) { if (seenExtendsClause) { return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); } @@ -22458,13 +18769,12 @@ var ts; seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 102 /* ImplementsKeyword */); + ts.Debug.assert(heritageClause.token === 102); if (seenImplementsClause) { return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen); } seenImplementsClause = true; } - // Grammar checking heritageClause inside class declaration checkGrammarHeritageClause(heritageClause); } } @@ -22474,29 +18784,27 @@ var ts; if (node.heritageClauses) { for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) { var heritageClause = _a[_i]; - if (heritageClause.token === 79 /* ExtendsKeyword */) { + if (heritageClause.token === 79) { if (seenExtendsClause) { return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); } seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 102 /* ImplementsKeyword */); + ts.Debug.assert(heritageClause.token === 102); return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause); } - // Grammar checking heritageClause inside class declaration checkGrammarHeritageClause(heritageClause); } } return false; } function checkGrammarComputedPropertyName(node) { - // If node is not a computedPropertyName, just skip the grammar checking - if (node.kind !== 128 /* ComputedPropertyName */) { + if (node.kind !== 128) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 170 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 23 /* CommaToken */) { + if (computedPropertyName.expression.kind === 170 && computedPropertyName.expression.operatorToken.kind === 23) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } @@ -22506,7 +18814,6 @@ var ts; } } function checkGrammarFunctionName(name) { - // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1)) return checkGrammarEvalOrArgumentsInStrictMode(name, name); } function checkGrammarForInvalidQuestionMark(node, questionToken, message) { @@ -22520,40 +18827,30 @@ var ts; var GetAccessor = 2; var SetAccesor = 4; var GetOrSetAccessor = GetAccessor | SetAccesor; - var inStrictMode = (node.parserContextFlags & 1 /* StrictMode */) !== 0; + var inStrictMode = (node.parserContextFlags & 1) !== 0; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var prop = _a[_i]; var name_13 = prop.name; - if (prop.kind === 176 /* OmittedExpression */ || - name_13.kind === 128 /* ComputedPropertyName */) { - // If the name is not a ComputedPropertyName, the grammar checking will skip it + if (prop.kind === 176 || + name_13.kind === 128) { checkGrammarComputedPropertyName(name_13); continue; } - // ECMA-262 11.1.5 Object Initialiser - // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true - // a.This production is contained in strict code and IsDataDescriptor(previous) is true and - // IsDataDescriptor(propId.descriptor) is true. - // b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true. - // c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true. - // d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true - // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields var currentKind = void 0; - if (prop.kind === 225 /* PropertyAssignment */ || prop.kind === 226 /* ShorthandPropertyAssignment */) { - // Grammar checking for computedPropertName and shorthandPropertyAssignment + if (prop.kind === 225 || prop.kind === 226) { checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); - if (name_13.kind === 7 /* NumericLiteral */) { + if (name_13.kind === 7) { checkGrammarNumericLiteral(name_13); } currentKind = Property; } - else if (prop.kind === 135 /* MethodDeclaration */) { + else if (prop.kind === 135) { currentKind = Property; } - else if (prop.kind === 137 /* GetAccessor */) { + else if (prop.kind === 137) { currentKind = GetAccessor; } - else if (prop.kind === 138 /* SetAccessor */) { + else if (prop.kind === 138) { currentKind = SetAccesor; } else { @@ -22587,24 +18884,24 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 200 /* VariableDeclarationList */) { + if (forInOrOfStatement.initializer.kind === 200) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 188 ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic); } var firstDeclaration = variableList.declarations[0]; if (firstDeclaration.initializer) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 188 ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; return grammarErrorOnNode(firstDeclaration.name, diagnostic); } if (firstDeclaration.type) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 188 ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; return grammarErrorOnNode(firstDeclaration, diagnostic); @@ -22615,7 +18912,7 @@ var ts; } function checkGrammarAccessor(accessor) { var kind = accessor.kind; - if (languageVersion < 1 /* ES5 */) { + if (languageVersion < 1) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher); } else if (ts.isInAmbientContext(accessor)) { @@ -22627,10 +18924,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 137 /* GetAccessor */ && accessor.parameters.length) { + else if (kind === 137 && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 138 /* SetAccessor */) { + else if (kind === 138) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -22642,7 +18939,7 @@ var ts; if (parameter.dotDotDotToken) { return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter); } - else if (parameter.flags & 499 /* Modifier */) { + else if (parameter.flags & 499) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } else if (parameter.questionToken) { @@ -22655,7 +18952,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 128 /* ComputedPropertyName */ && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 128 && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -22665,7 +18962,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 155 /* ObjectLiteralExpression */) { + if (node.parent.kind === 155) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -22673,15 +18970,10 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.kind === 202) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } - // Technically, computed properties in ambient contexts is disallowed - // for property declarations and accessors too, not just methods. - // However, property declarations disallow computed names in general, - // and accessors are not allowed in ambient contexts in general, - // so this error only really matters for methods. if (ts.isInAmbientContext(node)) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol); } @@ -22689,22 +18981,22 @@ var ts; return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol); } } - else if (node.parent.kind === 203 /* InterfaceDeclaration */) { + else if (node.parent.kind === 203) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol); } - else if (node.parent.kind === 146 /* TypeLiteral */) { + else if (node.parent.kind === 146) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol); } } function isIterationStatement(node, lookInLabeledStatements) { switch (node.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: + case 187: + case 188: + case 189: + case 185: + case 186: return true; - case 195 /* LabeledStatement */: + case 195: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -22716,11 +19008,9 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 195 /* LabeledStatement */: + case 195: if (node.label && current.label.text === node.label.text) { - // found matching label - verify that label usage is correct - // continue can only target labels that are on iteration statements - var isMisplacedContinueLabel = node.kind === 190 /* ContinueStatement */ + var isMisplacedContinueLabel = node.kind === 190 && !isIterationStatement(current.statement, true); if (isMisplacedContinueLabel) { return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement); @@ -22728,15 +19018,13 @@ var ts; return false; } break; - case 194 /* SwitchStatement */: - if (node.kind === 191 /* BreakStatement */ && !node.label) { - // unlabeled break within switch statement - ok + case 194: + if (node.kind === 191 && !node.label) { return false; } break; default: if (isIterationStatement(current, false) && !node.label) { - // unlabeled break or continue within iteration statement - ok return false; } break; @@ -22744,13 +19032,13 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 191 /* BreakStatement */ + var message = node.kind === 191 ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); } else { - var message = node.kind === 191 /* BreakStatement */ + var message = node.kind === 191 ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); @@ -22759,26 +19047,22 @@ var ts; function checkGrammarBindingElement(node) { if (node.dotDotDotToken) { var elements = node.parent.elements; - if (node !== elements[elements.length - 1]) { + if (node !== ts.lastOrUndefined(elements)) { return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern); } - if (node.name.kind === 152 /* ArrayBindingPattern */ || node.name.kind === 151 /* ObjectBindingPattern */) { + if (node.name.kind === 152 || node.name.kind === 151) { return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern); } if (node.initializer) { - // Error on equals token which immediate precedes the initializer return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } } - // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code - // and its Identifier is eval or arguments return checkGrammarEvalOrArgumentsInStrictMode(node, node.name); } function checkGrammarVariableDeclaration(node) { - if (node.parent.parent.kind !== 188 /* ForInStatement */ && node.parent.parent.kind !== 189 /* ForOfStatement */) { + if (node.parent.parent.kind !== 188 && node.parent.parent.kind !== 189) { if (ts.isInAmbientContext(node)) { if (node.initializer) { - // Error on equals token which immediate precedes the initializer var equalsTokenLength = "=".length; return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - equalsTokenLength, equalsTokenLength, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts); } @@ -22792,18 +19076,12 @@ var ts; } } } - var checkLetConstNames = languageVersion >= 2 /* ES6 */ && (ts.isLet(node) || ts.isConst(node)); - // 1. LexicalDeclaration : LetOrConst BindingList ; - // It is a Syntax Error if the BoundNames of BindingList contains "let". - // 2. ForDeclaration: ForDeclaration : LetOrConst ForBinding - // It is a Syntax Error if the BoundNames of ForDeclaration contains "let". - // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code - // and its Identifier is eval or arguments + var checkLetConstNames = languageVersion >= 2 && (ts.isLet(node) || ts.isConst(node)); return (checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name)) || checkGrammarEvalOrArgumentsInStrictMode(node, node.name); } function checkGrammarNameInLetOrConstDeclarations(name) { - if (name.kind === 65 /* Identifier */) { + if (name.kind === 65) { if (name.text === "let") { return grammarErrorOnNode(name, ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations); } @@ -22812,7 +19090,7 @@ var ts; var elements = name.elements; for (var _i = 0; _i < elements.length; _i++) { var element = elements[_i]; - if (element.kind !== 176 /* OmittedExpression */) { + if (element.kind !== 176) { checkGrammarNameInLetOrConstDeclarations(element.name); } } @@ -22829,15 +19107,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 184: + case 185: + case 186: + case 193: + case 187: + case 188: + case 189: return false; - case 195 /* LabeledStatement */: + case 195: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -22853,36 +19131,26 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 168 /* PrefixUnaryExpression */) { + if (expression.kind === 168) { var unaryExpression = expression; - if (unaryExpression.operator === 33 /* PlusToken */ || unaryExpression.operator === 34 /* MinusToken */) { + if (unaryExpression.operator === 33 || unaryExpression.operator === 34) { expression = unaryExpression.operand; } } - if (expression.kind === 7 /* NumericLiteral */) { - // Allows for scientific notation since literalExpression.text was formed by - // coercing a number to a string. Sometimes this coercion can yield a string - // in scientific notation. - // We also don't need special logic for hex because a hex integer is converted - // to decimal when it is coerced. + if (expression.kind === 7) { return /^[0-9]+([eE]\+?[0-9]+)?$/.test(expression.text); } return false; } function checkGrammarEnumDeclaration(enumDecl) { - var enumIsConst = (enumDecl.flags & 8192 /* Const */) !== 0; + var enumIsConst = (enumDecl.flags & 8192) !== 0; var hasError = false; - // skip checks below for const enums - they allow arbitrary initializers as long as they can be evaluated to constant expressions. - // since all values are known in compile time - it is not necessary to check that constant enum section precedes computed enum members. if (!enumIsConst) { var inConstantEnumMemberSection = true; var inAmbientContext = ts.isInAmbientContext(enumDecl); for (var _i = 0, _a = enumDecl.members; _i < _a.length; _i++) { var node = _a[_i]; - // Do not use hasDynamicName here, because that returns false for well known symbols. - // We want to perform checkComputedPropertyName for all computed properties, including - // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 128) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -22925,13 +19193,10 @@ var ts; } } function checkGrammarEvalOrArgumentsInStrictMode(contextNode, name) { - if (name && name.kind === 65 /* Identifier */) { + if (name && name.kind === 65) { var identifier = name; - if (contextNode && (contextNode.parserContextFlags & 1 /* StrictMode */) && isEvalOrArgumentsIdentifier(identifier)) { + if (contextNode && (contextNode.parserContextFlags & 1) && isEvalOrArgumentsIdentifier(identifier)) { var nameText = ts.declarationNameToString(identifier); - // We check first if the name is inside class declaration or class expression; if so give explicit message - // otherwise report generic error message. - // reportGrammarErrorInClassDeclaration only return true if grammar error is successfully reported and false otherwise var reportErrorInClassDeclaration = reportStrictModeGrammarErrorInClassDeclaration(identifier, ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode, nameText); if (!reportErrorInClassDeclaration) { return grammarErrorOnNode(identifier, ts.Diagnostics.Invalid_use_of_0_in_strict_mode, nameText); @@ -22941,7 +19206,7 @@ var ts; } } function isEvalOrArgumentsIdentifier(node) { - return node.kind === 65 /* Identifier */ && + return node.kind === 65 && (node.text === "eval" || node.text === "arguments"); } function checkGrammarConstructorTypeParameters(node) { @@ -22955,18 +19220,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.kind === 202) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 203 /* InterfaceDeclaration */) { + else if (node.parent.kind === 203) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 146 /* TypeLiteral */) { + else if (node.parent.kind === 146) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -22976,23 +19241,13 @@ var ts; } } function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { - // A declare modifier is required for any top level .d.ts declaration except export=, export default, - // interfaces and imports categories: - // - // DeclarationElement: - // ExportAssignment - // export_opt InterfaceDeclaration - // export_opt ImportDeclaration - // export_opt ExternalImportDeclaration - // export_opt AmbientDeclaration - // - if (node.kind === 203 /* InterfaceDeclaration */ || - node.kind === 210 /* ImportDeclaration */ || - node.kind === 209 /* ImportEqualsDeclaration */ || - node.kind === 216 /* ExportDeclaration */ || - node.kind === 215 /* ExportAssignment */ || - (node.flags & 2 /* Ambient */) || - (node.flags & (1 /* Export */ | 256 /* Default */))) { + if (node.kind === 203 || + node.kind === 210 || + node.kind === 209 || + node.kind === 216 || + node.kind === 215 || + (node.flags & 2) || + (node.flags & (1 | 256))) { return false; } return grammarErrorOnFirstToken(node, ts.Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file); @@ -23000,7 +19255,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { var decl = _a[_i]; - if (ts.isDeclaration(decl) || decl.kind === 181 /* VariableStatement */) { + if (ts.isDeclaration(decl) || decl.kind === 181) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -23012,23 +19267,15 @@ var ts; } function checkGrammarStatementInAmbientContext(node) { if (ts.isInAmbientContext(node)) { - // An accessors is already reported about the ambient context if (isAccessor(node.parent.kind)) { return getNodeLinks(node).hasReportedStatementInAmbientContext = true; } - // Find containing block which is either Block, ModuleBlock, SourceFile var links = getNodeLinks(node); if (!links.hasReportedStatementInAmbientContext && ts.isFunctionLike(node.parent)) { return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); } - // We are either parented by another statement, or some sort of block. - // If we're in a block, we only want to really report an error once - // to prevent noisyness. So use a bit on the block to indicate if - // this has already been reported, and don't report if it has. - // - if (node.parent.kind === 180 /* Block */ || node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + if (node.parent.kind === 180 || node.parent.kind === 207 || node.parent.kind === 228) { var links_1 = getNodeLinks(node.parent); - // Check if the containing block ever report this error if (!links_1.hasReportedStatementInAmbientContext) { return links_1.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); } @@ -23038,12 +19285,11 @@ var ts; } } function checkGrammarNumericLiteral(node) { - // Grammar checking - if (node.flags & 16384 /* OctalLiteral */) { - if (node.parserContextFlags & 1 /* StrictMode */) { + if (node.flags & 16384) { + if (node.parserContextFlags & 1) { return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode); } - else if (languageVersion >= 1 /* ES5 */) { + else if (languageVersion >= 1) { return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); } } @@ -23062,7 +19308,6 @@ var ts; ts.createTypeChecker = createTypeChecker; })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { function getDeclarationDiagnostics(host, resolver, targetSourceFile) { @@ -23075,7 +19320,7 @@ var ts; function emitDeclarations(host, resolver, diagnostics, jsFilePath, root) { var newLine = host.getNewLine(); var compilerOptions = host.getCompilerOptions(); - var languageVersion = compilerOptions.target || 0 /* ES3 */; + var languageVersion = compilerOptions.target || 0; var write; var writeLine; var increaseIndent; @@ -23089,18 +19334,13 @@ var ts; var emit = compilerOptions.stripInternal ? stripInternal : emitNode; var moduleElementDeclarationEmitInfo = []; var asynchronousSubModuleDeclarationEmitInfo; - // Contains the reference paths that needs to go in the declaration file. - // Collecting this separately because reference paths need to be first thing in the declaration file - // and we could be collecting these paths from multiple files into single one with --out option var referencePathsOutput = ""; if (root) { - // Emitting just a single file, so emit references in this file only if (!compilerOptions.noResolve) { var addedGlobalFileReference = false; ts.forEach(root.referencedFiles, function (fileReference) { var referencedFile = ts.tryResolveScriptReference(host, root, fileReference); - // All the references that are not going to be part of same file - if (referencedFile && ((referencedFile.flags & 2048 /* DeclarationFile */) || + if (referencedFile && ((referencedFile.flags & 2048) || ts.shouldEmitToOwnFile(referencedFile, compilerOptions) || !addedGlobalFileReference)) { writeReferencePath(referencedFile); @@ -23111,12 +19351,11 @@ var ts; }); } emitSourceFile(root); - // create asynchronous output for the importDeclarations if (moduleElementDeclarationEmitInfo.length) { var oldWriter = writer; ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) { if (aliasEmitInfo.isVisible) { - ts.Debug.assert(aliasEmitInfo.node.kind === 210 /* ImportDeclaration */); + ts.Debug.assert(aliasEmitInfo.node.kind === 210); createAndSetNewTextWriterWithSymbolWriter(); ts.Debug.assert(aliasEmitInfo.indent === 0); writeImportDeclaration(aliasEmitInfo.node); @@ -23127,15 +19366,12 @@ var ts; } } else { - // Emit references corresponding to this file var emittedReferencedFiles = []; ts.forEach(host.getSourceFiles(), function (sourceFile) { if (!ts.isExternalModuleOrDeclarationFile(sourceFile)) { - // Check what references need to be added if (!compilerOptions.noResolve) { ts.forEach(sourceFile.referencedFiles, function (fileReference) { var referencedFile = ts.tryResolveScriptReference(host, sourceFile, fileReference); - // If the reference file is a declaration file or an external module, emit that reference if (referencedFile && (ts.isExternalModuleOrDeclarationFile(referencedFile) && !ts.contains(emittedReferencedFiles, referencedFile))) { writeReferencePath(referencedFile); @@ -23192,10 +19428,10 @@ var ts; var oldWriter = writer; ts.forEach(nodes, function (declaration) { var nodeToCheck; - if (declaration.kind === 199 /* VariableDeclaration */) { + if (declaration.kind === 199) { nodeToCheck = declaration.parent.parent; } - else if (declaration.kind === 213 /* NamedImports */ || declaration.kind === 214 /* ImportSpecifier */ || declaration.kind === 211 /* ImportClause */) { + else if (declaration.kind === 213 || declaration.kind === 214 || declaration.kind === 211) { ts.Debug.fail("We should be getting ImportDeclaration instead to write"); } else { @@ -23205,17 +19441,8 @@ var ts; if (!moduleElementEmitInfo && asynchronousSubModuleDeclarationEmitInfo) { moduleElementEmitInfo = ts.forEach(asynchronousSubModuleDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined; }); } - // If the alias was marked as not visible when we saw its declaration, we would have saved the aliasEmitInfo, but if we haven't yet visited the alias declaration - // then we don't need to write it at this point. We will write it when we actually see its declaration - // Eg. - // export function bar(a: foo.Foo) { } - // import foo = require("foo"); - // Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing, - // we would write alias foo declaration when we visit it since it would now be marked as visible if (moduleElementEmitInfo) { - if (moduleElementEmitInfo.node.kind === 210 /* ImportDeclaration */) { - // we have to create asynchronous output only after we have collected complete information - // because it is possible to enable multiple bindings as asynchronously visible + if (moduleElementEmitInfo.node.kind === 210) { moduleElementEmitInfo.isVisible = true; } else { @@ -23223,12 +19450,12 @@ var ts; for (var declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - if (nodeToCheck.kind === 206 /* ModuleDeclaration */) { + if (nodeToCheck.kind === 206) { ts.Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined); asynchronousSubModuleDeclarationEmitInfo = []; } writeModuleElement(nodeToCheck); - if (nodeToCheck.kind === 206 /* ModuleDeclaration */) { + if (nodeToCheck.kind === 206) { moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo; asynchronousSubModuleDeclarationEmitInfo = undefined; } @@ -23239,14 +19466,12 @@ var ts; setWriter(oldWriter); } function handleSymbolAccessibilityError(symbolAccesibilityResult) { - if (symbolAccesibilityResult.accessibility === 0 /* Accessible */) { - // write the aliases + if (symbolAccesibilityResult.accessibility === 0) { if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) { writeAsynchronousModuleElements(symbolAccesibilityResult.aliasesToMakeVisible); } } else { - // Report error reportedDeclarationError = true; var errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult); if (errorInfo) { @@ -23266,22 +19491,20 @@ var ts; writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic; write(": "); if (type) { - // Write the type emitType(type); } else { - resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, 2 /* UseTypeOfFunction */, writer); + resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, 2, writer); } } function writeReturnTypeAtSignature(signature, getSymbolAccessibilityDiagnostic) { writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic; write(": "); if (signature.type) { - // Write the type emitType(signature.type); } else { - resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, 2 /* UseTypeOfFunction */, writer); + resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, 2, writer); } } function emitLines(nodes) { @@ -23310,7 +19533,6 @@ var ts; if (declaration) { var jsDocComments = ts.getJsDocComments(declaration, currentSourceFile); ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, declaration, jsDocComments); - // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space ts.emitComments(currentSourceFile, writer, jsDocComments, true, newLine, ts.writeCommentRange); } } @@ -23320,51 +19542,49 @@ var ts; } function emitType(type) { switch (type.kind) { - case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: - case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: - case 99 /* VoidKeyword */: - case 8 /* StringLiteral */: + case 112: + case 122: + case 120: + case 113: + case 123: + case 99: + case 8: return writeTextOfNode(currentSourceFile, type); - case 177 /* ExpressionWithTypeArguments */: + case 177: return emitExpressionWithTypeArguments(type); - case 142 /* TypeReference */: + case 142: return emitTypeReference(type); - case 145 /* TypeQuery */: + case 145: return emitTypeQuery(type); - case 147 /* ArrayType */: + case 147: return emitArrayType(type); - case 148 /* TupleType */: + case 148: return emitTupleType(type); - case 149 /* UnionType */: + case 149: return emitUnionType(type); - case 150 /* ParenthesizedType */: + case 150: return emitParenType(type); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 143: + case 144: return emitSignatureDeclarationWithJsDocComments(type); - case 146 /* TypeLiteral */: + case 146: return emitTypeLiteral(type); - case 65 /* Identifier */: + case 65: return emitEntityName(type); - case 127 /* QualifiedName */: + case 127: return emitEntityName(type); } function emitEntityName(entityName) { - var visibilityResult = resolver.isEntityNameVisible(entityName, - // Aliases can be written asynchronously so use correct enclosing declaration - entityName.parent.kind === 209 /* ImportEqualsDeclaration */ ? entityName.parent : enclosingDeclaration); + var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 209 ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { - if (entityName.kind === 65 /* Identifier */) { + if (entityName.kind === 65) { writeTextOfNode(currentSourceFile, entityName); } else { - var left = entityName.kind === 127 /* QualifiedName */ ? entityName.left : entityName.expression; - var right = entityName.kind === 127 /* QualifiedName */ ? entityName.right : entityName.name; + var left = entityName.kind === 127 ? entityName.left : entityName.expression; + var right = entityName.kind === 127 ? entityName.right : entityName.name; writeEntityName(left); write("."); writeTextOfNode(currentSourceFile, right); @@ -23373,7 +19593,7 @@ var ts; } function emitExpressionWithTypeArguments(node) { if (ts.isSupportedExpressionWithTypeArguments(node)) { - ts.Debug.assert(node.expression.kind === 65 /* Identifier */ || node.expression.kind === 156 /* PropertyAccessExpression */); + ts.Debug.assert(node.expression.kind === 65 || node.expression.kind === 156); emitEntityName(node.expression); if (node.typeArguments) { write("<"); @@ -23416,7 +19636,6 @@ var ts; if (type.members.length) { writeLine(); increaseIndent(); - // write members emitLines(type.members); decreaseIndent(); } @@ -23428,10 +19647,6 @@ var ts; enclosingDeclaration = node; emitLines(node.statements); } - // Return a temp variable name to be used in `export default` statements. - // The temp name will be of the form _default_counter. - // Note that export default is only allowed at most once in a module, so we - // do not need to keep track of created temp names. function getExportDefaultTempVariableName() { var baseName = "_default"; if (!ts.hasProperty(currentSourceFile.identifiers, baseName)) { @@ -23446,18 +19661,17 @@ var ts; } } function emitExportAssignment(node) { - if (node.expression.kind === 65 /* Identifier */) { + if (node.expression.kind === 65) { write(node.isExportEquals ? "export = " : "export default "); writeTextOfNode(currentSourceFile, node.expression); } else { - // Expression var tempVarName = getExportDefaultTempVariableName(); write("declare var "); write(tempVarName); write(": "); writer.getSymbolAccessibilityDiagnostic = getDefaultExportAccessibilityDiagnostic; - resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, 2 /* UseTypeOfFunction */, writer); + resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, 2, writer); write(";"); writeLine(); write(node.isExportEquals ? "export = " : "export default "); @@ -23465,10 +19679,8 @@ var ts; } write(";"); writeLine(); - // Make all the declarations visible for the export name - if (node.expression.kind === 65 /* Identifier */) { + if (node.expression.kind === 65) { var nodes = resolver.collectLinkedAliases(node.expression); - // write each of these declarations asynchronously writeAsynchronousModuleElements(nodes); } function getDefaultExportAccessibilityDiagnostic(diagnostic) { @@ -23485,11 +19697,10 @@ var ts; if (isModuleElementVisible) { writeModuleElement(node); } - else if (node.kind === 209 /* ImportEqualsDeclaration */ || - (node.parent.kind === 228 /* SourceFile */ && ts.isExternalModule(currentSourceFile))) { + else if (node.kind === 209 || + (node.parent.kind === 228 && ts.isExternalModule(currentSourceFile))) { var isVisible; - if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 228 /* SourceFile */) { - // Import declaration of another module that is visited async so lets put it in right spot + if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 228) { asynchronousSubModuleDeclarationEmitInfo.push({ node: node, outputPos: writer.getTextPos(), @@ -23498,7 +19709,7 @@ var ts; }); } else { - if (node.kind === 210 /* ImportDeclaration */) { + if (node.kind === 210) { var importDeclaration = node; if (importDeclaration.importClause) { isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) || @@ -23516,59 +19727,55 @@ var ts; } function writeModuleElement(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: + case 201: return writeFunctionDeclaration(node); - case 181 /* VariableStatement */: + case 181: return writeVariableStatement(node); - case 203 /* InterfaceDeclaration */: + case 203: return writeInterfaceDeclaration(node); - case 202 /* ClassDeclaration */: + case 202: return writeClassDeclaration(node); - case 204 /* TypeAliasDeclaration */: + case 204: return writeTypeAliasDeclaration(node); - case 205 /* EnumDeclaration */: + case 205: return writeEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 206: return writeModuleDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 209: return writeImportEqualsDeclaration(node); - case 210 /* ImportDeclaration */: + case 210: return writeImportDeclaration(node); default: ts.Debug.fail("Unknown symbol kind"); } } function emitModuleElementDeclarationFlags(node) { - // If the node is parented in the current source file we need to emit export declare or just export if (node.parent === currentSourceFile) { - // If the node is exported - if (node.flags & 1 /* Export */) { + if (node.flags & 1) { write("export "); } - if (node.flags & 256 /* Default */) { + if (node.flags & 256) { write("default "); } - else if (node.kind !== 203 /* InterfaceDeclaration */) { + else if (node.kind !== 203) { write("declare "); } } } function emitClassMemberDeclarationFlags(node) { - if (node.flags & 32 /* Private */) { + if (node.flags & 32) { write("private "); } - else if (node.flags & 64 /* Protected */) { + else if (node.flags & 64) { write("protected "); } - if (node.flags & 128 /* Static */) { + if (node.flags & 128) { write("static "); } } function writeImportEqualsDeclaration(node) { - // note usage of writer. methods instead of aliases created, just to make sure we are using - // correct writer especially to handle asynchronous alias writing emitJsDocComments(node); - if (node.flags & 1 /* Export */) { + if (node.flags & 1) { write("export "); } write("import "); @@ -23594,7 +19801,7 @@ var ts; } function isVisibleNamedBinding(namedBindings) { if (namedBindings) { - if (namedBindings.kind === 212 /* NamespaceImport */) { + if (namedBindings.kind === 212) { return resolver.isDeclarationVisible(namedBindings); } else { @@ -23603,12 +19810,11 @@ var ts; } } function writeImportDeclaration(node) { - if (!node.importClause && !(node.flags & 1 /* Export */)) { - // do not write non-exported import declarations that don't have import clauses + if (!node.importClause && !(node.flags & 1)) { return; } emitJsDocComments(node); - if (node.flags & 1 /* Export */) { + if (node.flags & 1) { write("export "); } write("import "); @@ -23619,10 +19825,9 @@ var ts; } if (node.importClause.namedBindings && isVisibleNamedBinding(node.importClause.namedBindings)) { if (currentWriterPos !== writer.getTextPos()) { - // If the default binding was emitted, write the separated write(", "); } - if (node.importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (node.importClause.namedBindings.kind === 212) { write("* as "); writeTextOfNode(currentSourceFile, node.importClause.namedBindings.name); } @@ -23647,9 +19852,7 @@ var ts; } function emitExportSpecifier(node) { emitImportOrExportSpecifier(node); - // Make all the declarations visible for the export name var nodes = resolver.collectLinkedAliases(node.propertyName || node.name); - // write each of these declarations asynchronously writeAsynchronousModuleElements(nodes); } function emitExportDeclaration(node) { @@ -23675,7 +19878,7 @@ var ts; emitModuleElementDeclarationFlags(node); write("module "); writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 207 /* ModuleBlock */) { + while (node.body.kind !== 207) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -23736,7 +19939,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 135 /* MethodDeclaration */ && (node.parent.flags & 32 /* Private */); + return node.parent.kind === 135 && (node.parent.flags & 32); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -23744,18 +19947,17 @@ var ts; emitJsDocComments(node); decreaseIndent(); writeTextOfNode(currentSourceFile, node.name); - // If there is constraint present and this is not a type parameter of the private method emit the constraint if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - (node.parent.parent && node.parent.parent.kind === 146 /* TypeLiteral */)) { - ts.Debug.assert(node.parent.kind === 135 /* MethodDeclaration */ || - node.parent.kind === 134 /* MethodSignature */ || - node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - node.parent.kind === 139 /* CallSignature */ || - node.parent.kind === 140 /* ConstructSignature */); + if (node.parent.kind === 143 || + node.parent.kind === 144 || + (node.parent.parent && node.parent.parent.kind === 146)) { + ts.Debug.assert(node.parent.kind === 135 || + node.parent.kind === 134 || + node.parent.kind === 143 || + node.parent.kind === 144 || + node.parent.kind === 139 || + node.parent.kind === 140); emitType(node.constraint); } else { @@ -23763,34 +19965,33 @@ var ts; } } function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult) { - // Type parameter constraints are named by user so we should always be able to name it var diagnosticMessage; switch (node.parent.kind) { - case 202 /* ClassDeclaration */: + case 202: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 203 /* InterfaceDeclaration */: + case 203: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 140 /* ConstructSignature */: + case 140: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 139 /* CallSignature */: + case 139: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - if (node.parent.flags & 128 /* Static */) { + case 135: + case 134: + if (node.parent.flags & 128) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.parent.kind === 202) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } break; - case 201 /* FunctionDeclaration */: + case 201: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -23820,15 +20021,12 @@ var ts; } function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - // Heritage clause is written by user so it can always be named - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { - // Class or Interface implemented/extended is inaccessible + if (node.parent.parent.kind === 202) { diagnosticMessage = isImplementsList ? ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : ts.Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1; } else { - // interface is inaccessible diagnosticMessage = ts.Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1; } return { @@ -23843,7 +20041,7 @@ var ts; function emitParameterProperties(constructorDeclaration) { if (constructorDeclaration) { ts.forEach(constructorDeclaration.parameters, function (param) { - if (param.flags & 112 /* AccessibilityModifier */) { + if (param.flags & 112) { emitPropertyDeclaration(param); } }); @@ -23900,55 +20098,47 @@ var ts; writeLine(); } function emitVariableDeclaration(node) { - // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted - // so there is no check needed to see if declaration is visible - if (node.kind !== 199 /* VariableDeclaration */ || resolver.isDeclarationVisible(node)) { + if (node.kind !== 199 || resolver.isDeclarationVisible(node)) { if (ts.isBindingPattern(node.name)) { emitBindingPattern(node.name); } else { - // If this node is a computed name, it can only be a symbol, because we've already skipped - // it if it's not a well known symbol. In that case, the text of the name will be exactly - // what we want, namely the name expression enclosed in brackets. writeTextOfNode(currentSourceFile, node.name); - // If optional property emit ? - if ((node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) && ts.hasQuestionToken(node)) { + if ((node.kind === 133 || node.kind === 132) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) && node.parent.kind === 146 /* TypeLiteral */) { + if ((node.kind === 133 || node.kind === 132) && node.parent.kind === 146) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } - else if (!(node.flags & 32 /* Private */)) { + else if (!(node.flags & 32)) { writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError); } } } function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { - if (node.kind === 199 /* VariableDeclaration */) { + if (node.kind === 199) { return symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; } - else if (node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) { - // TODO(jfreeman): Deal with computed properties in error reporting. - if (node.flags & 128 /* Static */) { + else if (node.kind === 133 || node.kind === 132) { + if (node.flags & 128) { return symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 202) { return symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; } else { - // Interfaces cannot have types that cannot be named return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1; @@ -23964,15 +20154,10 @@ var ts; } : undefined; } function emitBindingPattern(bindingPattern) { - // Only select non-omitted expression from the bindingPattern's elements. - // We have to do this to avoid emitting trailing commas. - // For example: - // original: var [, c,,] = [ 2,3,4] - // emitted: declare var c: number; // instead of declare var c:number, ; var elements = []; for (var _i = 0, _a = bindingPattern.elements; _i < _a.length; _i++) { var element = _a[_i]; - if (element.kind !== 176 /* OmittedExpression */) { + if (element.kind !== 176) { elements.push(element); } } @@ -23999,9 +20184,6 @@ var ts; } } function emitTypeOfVariableDeclarationFromTypeLiteral(node) { - // if this is property of type literal, - // or is parameter of method/call/construct/index signature of type literal - // emit only if type is specified if (node.type) { write(": "); emitType(node.type); @@ -24037,12 +20219,11 @@ var ts; emitJsDocComments(accessors.setAccessor); emitClassMemberDeclarationFlags(node); writeTextOfNode(currentSourceFile, node.name); - if (!(node.flags & 32 /* Private */)) { + if (!(node.flags & 32)) { accessorWithTypeAnnotation = node; var type = getTypeAnnotationFromAccessor(node); if (!type) { - // couldn't get type for the first accessor, try the another one - var anotherAccessor = node.kind === 137 /* GetAccessor */ ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 137 ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -24055,18 +20236,17 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 137 /* GetAccessor */ - ? accessor.type // Getter - return type + return accessor.kind === 137 + ? accessor.type : accessor.parameters.length > 0 - ? accessor.parameters[0].type // Setter parameter type + ? accessor.parameters[0].type : undefined; } } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 138 /* SetAccessor */) { - // Setters have to have type named and cannot infer it so, the type should always be named - if (accessorWithTypeAnnotation.parent.flags & 128 /* Static */) { + if (accessorWithTypeAnnotation.kind === 138) { + if (accessorWithTypeAnnotation.parent.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1; @@ -24079,21 +20259,20 @@ var ts; return { diagnosticMessage: diagnosticMessage, errorNode: accessorWithTypeAnnotation.parameters[0], - // TODO(jfreeman): Investigate why we are passing node.name instead of node.parameters[0].name typeName: accessorWithTypeAnnotation.name }; } else { - if (accessorWithTypeAnnotation.flags & 128 /* Static */) { + if (accessorWithTypeAnnotation.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0; } else { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0; @@ -24110,21 +20289,19 @@ var ts; if (ts.hasDynamicName(node)) { return; } - // If we are emitting Method/Constructor it isn't moduleElement and hence already determined to be emitting - // so no need to verify if the declaration is visible if (!resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 201) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 135 /* MethodDeclaration */) { + else if (node.kind === 135) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 201) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 136 /* Constructor */) { + else if (node.kind === 136) { write("constructor"); } else { @@ -24141,12 +20318,11 @@ var ts; emitSignatureDeclaration(node); } function emitSignatureDeclaration(node) { - // Construct signature or constructor type write new Signature - if (node.kind === 140 /* ConstructSignature */ || node.kind === 144 /* ConstructorType */) { + if (node.kind === 140 || node.kind === 144) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 141) { write("["); } else { @@ -24154,24 +20330,21 @@ var ts; } var prevEnclosingDeclaration = enclosingDeclaration; enclosingDeclaration = node; - // Parameters emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 141) { write("]"); } else { write(")"); } - // If this is not a constructor and is not private, emit the return type - var isFunctionTypeOrConstructorType = node.kind === 143 /* FunctionType */ || node.kind === 144 /* ConstructorType */; - if (isFunctionTypeOrConstructorType || node.parent.kind === 146 /* TypeLiteral */) { - // Emit type literal signature return type only if specified + var isFunctionTypeOrConstructorType = node.kind === 143 || node.kind === 144; + if (isFunctionTypeOrConstructorType || node.parent.kind === 146) { if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 136 /* Constructor */ && !(node.flags & 32 /* Private */)) { + else if (node.kind !== 136 && !(node.flags & 32)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -24182,50 +20355,46 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 140 /* ConstructSignature */: - // Interfaces cannot have return types that cannot be named + case 140: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 139 /* CallSignature */: - // Interfaces cannot have return types that cannot be named + case 139: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 141 /* IndexSignature */: - // Interfaces cannot have return types that cannot be named + case 141: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - if (node.flags & 128 /* Static */) { + case 135: + case 134: + if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0; } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 202) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0; } else { - // Interfaces cannot have return types that cannot be named diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 201 /* FunctionDeclaration */: + case 201: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0; @@ -24246,9 +20415,6 @@ var ts; write("..."); } if (ts.isBindingPattern(node.name)) { - // For bindingPattern, we can't simply writeTextOfNode from the source file - // because we want to omit the initializer and using writeTextOfNode will result in initializer get emitted. - // Therefore, we will have to recursively emit each element in the bindingPattern. emitBindingPattern(node.name); } else { @@ -24258,12 +20424,12 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - node.parent.parent.kind === 146 /* TypeLiteral */) { + if (node.parent.kind === 143 || + node.parent.kind === 144 || + node.parent.parent.kind === 146) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } - else if (!(node.parent.flags & 32 /* Private */)) { + else if (!(node.parent.flags & 32)) { writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError); } function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) { @@ -24276,47 +20442,44 @@ var ts; } function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { switch (node.parent.kind) { - case 136 /* Constructor */: + case 136: return symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; - case 140 /* ConstructSignature */: - // Interfaces cannot have parameter types that cannot be named + case 140: return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; - case 139 /* CallSignature */: - // Interfaces cannot have parameter types that cannot be named + case 139: return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - if (node.parent.flags & 128 /* Static */) { + case 135: + case 134: + if (node.parent.flags & 128) { return symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.parent.kind === 202) { return symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { - // Interfaces cannot have parameter types that cannot be named return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } - case 201 /* FunctionDeclaration */: + case 201: return symbolAccesibilityResult.errorModuleName ? - symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? + symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1; @@ -24325,13 +20488,12 @@ var ts; } } function emitBindingPattern(bindingPattern) { - // We have to explicitly emit square bracket and bracket because these tokens are not store inside the node. - if (bindingPattern.kind === 151 /* ObjectBindingPattern */) { + if (bindingPattern.kind === 151) { write("{"); emitCommaList(bindingPattern.elements, emitBindingElement); write("}"); } - else if (bindingPattern.kind === 152 /* ArrayBindingPattern */) { + else if (bindingPattern.kind === 152) { write("["); var elements = bindingPattern.elements; emitCommaList(elements, emitBindingElement); @@ -24350,45 +20512,21 @@ var ts; typeName: bindingElement.name } : undefined; } - if (bindingElement.kind === 176 /* OmittedExpression */) { - // If bindingElement is an omittedExpression (i.e. containing elision), - // we will emit blank space (although this may differ from users' original code, - // it allows emitSeparatedList to write separator appropriately) - // Example: - // original: function foo([, x, ,]) {} - // emit : function foo([ , x, , ]) {} + if (bindingElement.kind === 176) { write(" "); } - else if (bindingElement.kind === 153 /* BindingElement */) { + else if (bindingElement.kind === 153) { if (bindingElement.propertyName) { - // bindingElement has propertyName property in the following case: - // { y: [a,b,c] ...} -> bindingPattern will have a property called propertyName for "y" - // We have to explicitly emit the propertyName before descending into its binding elements. - // Example: - // original: function foo({y: [a,b,c]}) {} - // emit : declare function foo({y: [a, b, c]}: { y: [any, any, any] }) void; writeTextOfNode(currentSourceFile, bindingElement.propertyName); write(": "); - // If bindingElement has propertyName property, then its name must be another bindingPattern of SyntaxKind.ObjectBindingPattern emitBindingPattern(bindingElement.name); } else if (bindingElement.name) { if (ts.isBindingPattern(bindingElement.name)) { - // If it is a nested binding pattern, we will recursively descend into each element and emit each one separately. - // In the case of rest element, we will omit rest element. - // Example: - // original: function foo([a, [[b]], c] = [1,[["string"]], 3]) {} - // emit : declare function foo([a, [[b]], c]: [number, [[string]], number]): void; - // original with rest: function foo([a, ...c]) {} - // emit : declare function foo([a, ...c]): void; emitBindingPattern(bindingElement.name); } else { - ts.Debug.assert(bindingElement.name.kind === 65 /* Identifier */); - // If the node is just an identifier, we will simply emit the text associated with the node's name - // Example: - // original: function foo({y = 10, x}) {} - // emit : declare function foo({y, x}: {number, any}): void; + ts.Debug.assert(bindingElement.name.kind === 65); if (bindingElement.dotDotDotToken) { write("..."); } @@ -24400,59 +20538,54 @@ var ts; } function emitNode(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 203 /* InterfaceDeclaration */: - case 202 /* ClassDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: + case 201: + case 206: + case 209: + case 203: + case 202: + case 204: + case 205: return emitModuleElement(node, isModuleElementVisible(node)); - case 181 /* VariableStatement */: + case 181: return emitModuleElement(node, isVariableStatementVisible(node)); - case 210 /* ImportDeclaration */: - // Import declaration without import clause is visible, otherwise it is not visible + case 210: return emitModuleElement(node, !node.importClause); - case 216 /* ExportDeclaration */: + case 216: return emitExportDeclaration(node); - case 136 /* Constructor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136: + case 135: + case 134: return writeFunctionDeclaration(node); - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 141 /* IndexSignature */: + case 140: + case 139: + case 141: return emitSignatureDeclarationWithJsDocComments(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 137: + case 138: return emitAccessorDeclaration(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 133: + case 132: return emitPropertyDeclaration(node); - case 227 /* EnumMember */: + case 227: return emitEnumMemberDeclaration(node); - case 215 /* ExportAssignment */: + case 215: return emitExportAssignment(node); - case 228 /* SourceFile */: + case 228: return emitSourceFile(node); } } function writeReferencePath(referencedFile) { - var declFileName = referencedFile.flags & 2048 /* DeclarationFile */ - ? referencedFile.fileName // Declaration file, use declaration file name + var declFileName = referencedFile.flags & 2048 + ? referencedFile.fileName : ts.shouldEmitToOwnFile(referencedFile, compilerOptions) - ? ts.getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") // Own output file so get the .d.ts file - : ts.removeFileExtension(compilerOptions.out) + ".d.ts"; // Global out file - declFileName = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizeSlashes(jsFilePath)), declFileName, host.getCurrentDirectory(), host.getCanonicalFileName, - /*isAbsolutePathAnUrl*/ false); + ? ts.getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") + : ts.removeFileExtension(compilerOptions.out) + ".d.ts"; + declFileName = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizeSlashes(jsFilePath)), declFileName, host.getCurrentDirectory(), host.getCanonicalFileName, false); referencePathsOutput += "/// " + newLine; } } - /* @internal */ function writeDeclarationFile(jsFilePath, sourceFile, host, resolver, diagnostics) { var emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile); - // TODO(shkamat): Should we not write any declaration file if any of them can produce error, - // or should we just not write this file like we are doing now if (!emitDeclarationResult.reportedDeclarationError) { var declarationOutput = emitDeclarationResult.referencePathsOutput + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo); @@ -24461,7 +20594,6 @@ var ts; function getDeclarationOutput(synchronousDeclarationOutput, moduleElementDeclarationEmitInfo) { var appliedSyncOutputPos = 0; var declarationOutput = ""; - // apply asynchronous additions to the synchronous output ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) { if (aliasEmitInfo.asynchronousOutput) { declarationOutput += synchronousDeclarationOutput.substring(appliedSyncOutputPos, aliasEmitInfo.outputPos); @@ -24477,32 +20609,19 @@ var ts; })(ts || (ts = {})); /// /// -/* @internal */ var ts; (function (ts) { function isExternalModuleOrDeclarationFile(sourceFile) { return ts.isExternalModule(sourceFile) || ts.isDeclarationFile(sourceFile); } ts.isExternalModuleOrDeclarationFile = isExternalModuleOrDeclarationFile; - // Flags enum to track count of temp variables and a few dedicated names - var TempFlags; - (function (TempFlags) { - TempFlags[TempFlags["Auto"] = 0] = "Auto"; - TempFlags[TempFlags["CountMask"] = 268435455] = "CountMask"; - TempFlags[TempFlags["_i"] = 268435456] = "_i"; - })(TempFlags || (TempFlags = {})); - // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature function emitFiles(resolver, host, targetSourceFile) { - // emit output for the __extends helper function var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n __.prototype = b.prototype;\n d.prototype = new __();\n};"; - // emit output for the __decorate helper function var decorateHelper = "\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") return Reflect.decorate(decorators, target, key, desc);\n switch (arguments.length) {\n case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);\n case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);\n case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);\n }\n};"; - // emit output for the __metadata helper function var metadataHelper = "\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};"; - // emit output for the __param helper function var paramHelper = "\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n};"; var compilerOptions = host.getCompilerOptions(); - var languageVersion = compilerOptions.target || 0 /* ES3 */; + var languageVersion = compilerOptions.target || 0; var sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined; var diagnostics = []; var newLine = host.getNewLine(); @@ -24518,7 +20637,6 @@ var ts; } } else { - // targetSourceFile is specified (e.g calling emitter from language service or calling getSemanticDiagnostic from language service) if (ts.shouldEmitToOwnFile(targetSourceFile, compilerOptions)) { var jsFilePath = ts.getOwnEmitOutputFilePath(targetSourceFile, host, ".js"); emitFile(jsFilePath, targetSourceFile); @@ -24527,7 +20645,6 @@ var ts; emitFile(compilerOptions.out); } } - // Sort and make the unique list of diagnostics diagnostics = ts.sortAndDeduplicateDiagnostics(diagnostics); return { emitSkipped: false, @@ -24545,8 +20662,7 @@ var ts; function isUniqueLocalName(name, container) { for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) { if (node.locals && ts.hasProperty(node.locals, name)) { - // We conservatively include alias symbols to cover cases where they're emitted as locals - if (node.locals[name].flags & (107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */)) { + if (node.locals[name].flags & (107455 | 1048576 | 8388608)) { return false; } } @@ -24561,12 +20677,6 @@ var ts; var increaseIndent = writer.increaseIndent; var decreaseIndent = writer.decreaseIndent; var currentSourceFile; - // name of an exporter function if file is a System external module - // System.register([...], function () {...}) - // exporting in System modules looks like: - // export var x; ... x = 1 - // => - // var x;... exporter("x", x = 1) var exportFunctionForFile; var generatedNameSet = {}; var nodeToGeneratedName = []; @@ -24582,36 +20692,20 @@ var ts; var exportSpecifiers; var exportEquals; var hasExportStars; - /** write emitted output to disk*/ var writeEmittedFiles = writeJavaScriptFile; var detachedCommentsInfo; var writeComment = ts.writeCommentRange; - /** Emit a node */ var emit = emitNodeWithoutSourceMap; - /** Called just before starting emit of a node */ var emitStart = function (node) { }; - /** Called once the emit of the node is done */ var emitEnd = function (node) { }; - /** Emit the text for the given token that comes after startPos - * This by default writes the text provided with the given tokenKind - * but if optional emitFn callback is provided the text is emitted using the callback instead of default text - * @param tokenKind the kind of the token to search and emit - * @param startPos the position in the source to start searching for the token - * @param emitFn if given will be invoked to emit the text instead of actual token emit */ var emitToken = emitTokenText; - /** Called to before starting the lexical scopes as in function/class in the emitted code because of node - * @param scopeDeclaration node that starts the lexical scope - * @param scopeName Optional name of this scope instead of deducing one from the declaration node */ var scopeEmitStart = function (scopeDeclaration, scopeName) { }; - /** Called after coming out of the scope */ var scopeEmitEnd = function () { }; - /** Sourcemap data that will get encoded */ var sourceMapData; if (compilerOptions.sourceMap || compilerOptions.inlineSourceMap) { initializeEmitterWithSourceMaps(); } if (root) { - // Do not call emit directly. It does not set the currentSourceFile. emitSourceFile(root); } else { @@ -24634,36 +20728,27 @@ var ts; !ts.hasProperty(currentSourceFile.identifiers, name) && !ts.hasProperty(generatedNameSet, name); } - // Return the next available name in the pattern _a ... _z, _0, _1, ... - // TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name. - // Note that names generated by makeTempVariableName and makeUniqueName will never conflict. function makeTempVariableName(flags) { if (flags && !(tempFlags & flags)) { - var name = flags === 268435456 /* _i */ ? "_i" : "_n"; + var name = flags === 268435456 ? "_i" : "_n"; if (isUniqueName(name)) { tempFlags |= flags; return name; } } while (true) { - var count = tempFlags & 268435455 /* CountMask */; + var count = tempFlags & 268435455; tempFlags++; - // Skip over 'i' and 'n' if (count !== 8 && count !== 13) { - var name_15 = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26); + var name_15 = count < 26 ? "_" + String.fromCharCode(97 + count) : "_" + (count - 26); if (isUniqueName(name_15)) { return name_15; } } } } - // Generate a name that is unique within the current file and doesn't conflict with any names - // in global scope. The name is formed by adding an '_n' suffix to the specified base name, - // where n is a positive integer. Note that names generated by makeTempVariableName and - // makeUniqueName are guaranteed to never conflict. function makeUniqueName(baseName) { - // Find the first unique 'name_n', where n is a positive number - if (baseName.charCodeAt(baseName.length - 1) !== 95 /* _ */) { + if (baseName.charCodeAt(baseName.length - 1) !== 95) { baseName += "_"; } var i = 1; @@ -24684,15 +20769,14 @@ var ts; } } function generateNameForModuleOrEnum(node) { - if (node.name.kind === 65 /* Identifier */) { + if (node.name.kind === 65) { var name_16 = node.name.text; - // Use module/enum name itself if it is unique, otherwise make a unique variation assignGeneratedName(node, isUniqueLocalName(name_16, node) ? name_16 : makeUniqueName(name_16)); } } function generateNameForImportOrExportDeclaration(node) { var expr = ts.getExternalModuleName(node); - var baseName = expr.kind === 8 /* StringLiteral */ ? + var baseName = expr.kind === 8 ? ts.escapeIdentifier(ts.makeIdentifierFromModuleName(expr.text)) : "module"; assignGeneratedName(node, makeUniqueName(baseName)); } @@ -24707,31 +20791,31 @@ var ts; } } function generateNameForExportAssignment(node) { - if (node.expression && node.expression.kind !== 65 /* Identifier */) { + if (node.expression && node.expression.kind !== 65) { assignGeneratedName(node, makeUniqueName("default")); } } function generateNameForNode(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: + case 201: + case 202: + case 175: generateNameForFunctionOrClassDeclaration(node); break; - case 206 /* ModuleDeclaration */: + case 206: generateNameForModuleOrEnum(node); generateNameForNode(node.body); break; - case 205 /* EnumDeclaration */: + case 205: generateNameForModuleOrEnum(node); break; - case 210 /* ImportDeclaration */: + case 210: generateNameForImportDeclaration(node); break; - case 216 /* ExportDeclaration */: + case 216: generateNameForExportDeclaration(node); break; - case 215 /* ExportAssignment */: + case 215: generateNameForExportAssignment(node); break; } @@ -24744,16 +20828,13 @@ var ts; return nodeToGeneratedName[nodeId]; } function initializeEmitterWithSourceMaps() { - var sourceMapDir; // The directory in which sourcemap will be - // Current source map file and its index in the sources list + var sourceMapDir; var sourceMapSourceIndex = -1; - // Names and its index map var sourceMapNameIndexMap = {}; var sourceMapNameIndices = []; function getSourceMapNameIndex() { - return sourceMapNameIndices.length ? sourceMapNameIndices[sourceMapNameIndices.length - 1] : -1; + return sourceMapNameIndices.length ? ts.lastOrUndefined(sourceMapNameIndices) : -1; } - // Last recorded and encoded spans var lastRecordedSourceMapSpan; var lastEncodedSourceMapSpan = { emittedLine: 1, @@ -24763,35 +20844,26 @@ var ts; sourceIndex: 0 }; var lastEncodedNameIndex = 0; - // Encoding for sourcemap span function encodeLastRecordedSourceMapSpan() { if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) { return; } var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; - // Line/Comma delimiters if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) { - // Emit comma to separate the entry if (sourceMapData.sourceMapMappings) { sourceMapData.sourceMapMappings += ","; } } else { - // Emit line delimiters for (var encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) { sourceMapData.sourceMapMappings += ";"; } prevEncodedEmittedColumn = 1; } - // 1. Relative Column 0 based sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn); - // 2. Relative sourceIndex sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex); - // 3. Relative sourceLine 0 based sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine); - // 4. Relative sourceColumn 0 based sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn); - // 5. Relative namePosition 0 based if (lastRecordedSourceMapSpan.nameIndex >= 0) { sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex); lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex; @@ -24805,24 +20877,17 @@ var ts; } throw TypeError(inValue + ": not a 64 based value"); } - // Add a new least significant bit that has the sign of the value. - // if negative number the least significant bit that gets added to the number has value 1 - // else least significant bit value that gets added is 0 - // eg. -1 changes to binary : 01 [1] => 3 - // +1 changes to binary : 01 [0] => 2 if (inValue < 0) { inValue = ((-inValue) << 1) + 1; } else { inValue = inValue << 1; } - // Encode 5 bits at a time starting from least significant bits var encodedStr = ""; do { - var currentDigit = inValue & 31; // 11111 + var currentDigit = inValue & 31; inValue = inValue >> 5; if (inValue > 0) { - // There are still more digits to decode, set the msb (6th bit) currentDigit = currentDigit | 32; } encodedStr = encodedStr + base64FormatEncode(currentDigit); @@ -24832,21 +20897,17 @@ var ts; } function recordSourceMapSpan(pos) { var sourceLinePos = ts.getLineAndCharacterOfPosition(currentSourceFile, pos); - // Convert the location to be one-based. sourceLinePos.line++; sourceLinePos.character++; var emittedLine = writer.getLine(); var emittedColumn = writer.getColumn(); - // If this location wasn't recorded or the location in source is going backwards, record the span if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan.emittedLine != emittedLine || lastRecordedSourceMapSpan.emittedColumn != emittedColumn || (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { - // Encode the last recordedSpan before assigning new encodeLastRecordedSourceMapSpan(); - // New span lastRecordedSourceMapSpan = { emittedLine: emittedLine, emittedColumn: emittedColumn, @@ -24857,14 +20918,12 @@ var ts; }; } else { - // Take the new pos instead since there is no change in emittedLine and column since last location lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line; lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character; lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex; } } function recordEmitNodeStartSpan(node) { - // Get the token pos after skipping to the token (ignoring the leading trivia) recordSourceMapSpan(ts.skipTrivia(currentSourceFile.text, node.pos)); } function recordEmitNodeEndSpan(node) { @@ -24878,14 +20937,9 @@ var ts; return tokenEndPos; } function recordNewSourceFileStart(node) { - // Add the file to tsFilePaths - // If sourceroot option: Use the relative path corresponding to the common directory path - // otherwise source locations relative to map file location var sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir; - sourceMapData.sourceMapSources.push(ts.getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, node.fileName, host.getCurrentDirectory(), host.getCanonicalFileName, - /*isAbsolutePathAnUrl*/ true)); + sourceMapData.sourceMapSources.push(ts.getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, node.fileName, host.getCurrentDirectory(), host.getCanonicalFileName, true)); sourceMapSourceIndex = sourceMapData.sourceMapSources.length - 1; - // The one that can be used from program to get the actual source file sourceMapData.inputSourceFileNames.push(node.fileName); if (compilerOptions.inlineSources) { if (!sourceMapData.sourceMapSourcesContent) { @@ -24903,11 +20957,8 @@ var ts; if (scopeName) { var parentIndex = getSourceMapNameIndex(); if (parentIndex !== -1) { - // Child scopes are always shown with a dot (even if they have no name), - // unless it is a computed property. Then it is shown with brackets, - // but the brackets are included in the name. var name_17 = node.name; - if (!name_17 || name_17.kind !== 128 /* ComputedPropertyName */) { + if (!name_17 || name_17.kind !== 128) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -24922,30 +20973,26 @@ var ts; recordScopeNameIndex(scopeNameIndex); } if (scopeName) { - // The scope was already given a name use it recordScopeNameStart(scopeName); } - else if (node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */ || - node.kind === 135 /* MethodDeclaration */ || - node.kind === 134 /* MethodSignature */ || - node.kind === 137 /* GetAccessor */ || - node.kind === 138 /* SetAccessor */ || - node.kind === 206 /* ModuleDeclaration */ || - node.kind === 202 /* ClassDeclaration */ || - node.kind === 205 /* EnumDeclaration */) { - // Declaration and has associated name use it + else if (node.kind === 201 || + node.kind === 163 || + node.kind === 135 || + node.kind === 134 || + node.kind === 137 || + node.kind === 138 || + node.kind === 206 || + node.kind === 202 || + node.kind === 205) { if (node.name) { var name_18 = node.name; - // For computed property names, the text will include the brackets - scopeName = name_18.kind === 128 /* ComputedPropertyName */ + scopeName = name_18.kind === 128 ? ts.getTextOfNode(name_18) : node.name.text; } recordScopeNameStart(scopeName); } else { - // Block just use the name from upper level scope recordScopeNameIndex(getSourceMapNameIndex()); } } @@ -24991,19 +21038,15 @@ var ts; sourceMapDataList.push(sourceMapData); var sourceMapUrl; if (compilerOptions.inlineSourceMap) { - // Encode the sourceMap into the sourceMap url var base64SourceMapText = ts.convertToBase64(sourceMapText); sourceMapUrl = "//# sourceMappingURL=data:application/json;base64," + base64SourceMapText; } else { - // Write source map file ts.writeFile(host, diagnostics, sourceMapData.sourceMapFilePath, sourceMapText, false); sourceMapUrl = "//# sourceMappingURL=" + sourceMapData.jsSourceMappingURL; } - // Write sourcemap url to the js file and write the js file writeJavaScriptFile(emitOutput + sourceMapUrl, writeByteOrderMark); } - // Initialize source map data var sourceMapJsFile = ts.getBaseFileName(ts.normalizeSlashes(jsFilePath)); sourceMapData = { sourceMapFilePath: jsFilePath + ".map", @@ -25017,24 +21060,18 @@ var ts; sourceMapSourcesContent: undefined, sourceMapDecodedMappings: [] }; - // Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the - // relative paths of the sources list in the sourcemap sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot); - if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== 47 /* slash */) { + if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== 47) { sourceMapData.sourceMapSourceRoot += ts.directorySeparator; } if (compilerOptions.mapRoot) { sourceMapDir = ts.normalizeSlashes(compilerOptions.mapRoot); if (root) { - // For modules or multiple emit files the mapRoot will have directory structure like the sources - // So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map sourceMapDir = ts.getDirectoryPath(ts.getSourceFilePathInNewDir(root, host, sourceMapDir)); } if (!ts.isRootedDiskPath(sourceMapDir) && !ts.isUrl(sourceMapDir)) { - // The relative paths are relative to the common directory sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir); - sourceMapData.jsSourceMappingURL = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(jsFilePath)), ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), host.getCurrentDirectory(), host.getCanonicalFileName, - /*isAbsolutePathAnUrl*/ true); + sourceMapData.jsSourceMappingURL = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(jsFilePath)), ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), host.getCurrentDirectory(), host.getCanonicalFileName, true); } else { sourceMapData.jsSourceMappingURL = ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL); @@ -25048,7 +21085,7 @@ var ts; if (ts.nodeIsSynthesized(node)) { return emitNodeWithoutSourceMap(node, false); } - if (node.kind != 228 /* SourceFile */) { + if (node.kind != 228) { recordEmitNodeStartSpan(node); emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers); recordEmitNodeEndSpan(node); @@ -25071,9 +21108,8 @@ var ts; function writeJavaScriptFile(emitOutput, writeByteOrderMark) { ts.writeFile(host, diagnostics, jsFilePath, emitOutput, writeByteOrderMark); } - // Create a temporary variable with a unique unused name. function createTempVariable(flags) { - var result = ts.createSynthesizedNode(65 /* Identifier */); + var result = ts.createSynthesizedNode(65); result.text = makeTempVariableName(flags); return result; } @@ -25209,12 +21245,12 @@ var ts; } } function isBinaryOrOctalIntegerLiteral(node, text) { - if (node.kind === 7 /* NumericLiteral */ && text.length > 1) { + if (node.kind === 7 && text.length > 1) { switch (text.charCodeAt(1)) { - case 98 /* b */: - case 66 /* B */: - case 111 /* o */: - case 79 /* O */: + case 98: + case 66: + case 111: + case 79: return true; } } @@ -25222,10 +21258,10 @@ var ts; } function emitLiteral(node) { var text = getLiteralText(node); - if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap) && (node.kind === 8 /* StringLiteral */ || ts.isTemplateLiteralKind(node.kind))) { + if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap) && (node.kind === 8 || ts.isTemplateLiteralKind(node.kind))) { writer.writeLiteral(text); } - else if (languageVersion < 2 /* ES6 */ && isBinaryOrOctalIntegerLiteral(node, text)) { + else if (languageVersion < 2 && isBinaryOrOctalIntegerLiteral(node, text)) { write(node.text); } else { @@ -25233,30 +21269,24 @@ var ts; } } function getLiteralText(node) { - // Any template literal or string literal with an extended escape - // (e.g. "\u{0067}") will need to be downleveled as a escaped string literal. - if (languageVersion < 2 /* ES6 */ && (ts.isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) { + if (languageVersion < 2 && (ts.isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) { return getQuotedEscapedLiteralText('"', node.text, '"'); } - // If we don't need to downlevel and we can reach the original source text using - // the node's parent reference, then simply get the text as it was originally written. if (node.parent) { return ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node); } - // If we can't reach the original source text, use the canonical form if it's a number, - // or an escaped quoted form of the original text if it's string-like. switch (node.kind) { - case 8 /* StringLiteral */: + case 8: return getQuotedEscapedLiteralText('"', node.text, '"'); - case 10 /* NoSubstitutionTemplateLiteral */: + case 10: return getQuotedEscapedLiteralText('`', node.text, '`'); - case 11 /* TemplateHead */: + case 11: return getQuotedEscapedLiteralText('`', node.text, '${'); - case 12 /* TemplateMiddle */: + case 12: return getQuotedEscapedLiteralText('}', node.text, '${'); - case 13 /* TemplateTail */: + case 13: return getQuotedEscapedLiteralText('}', node.text, '`'); - case 7 /* NumericLiteral */: + case 7: return node.text; } ts.Debug.fail("Literal kind '" + node.kind + "' not accounted for."); @@ -25265,26 +21295,16 @@ var ts; return leftQuote + ts.escapeNonAsciiCharacters(ts.escapeString(text)) + rightQuote; } function emitDownlevelRawTemplateLiteral(node) { - // Find original source text, since we need to emit the raw strings of the tagged template. - // The raw strings contain the (escaped) strings of what the user wrote. - // Examples: `\n` is converted to "\\n", a template string with a newline to "\n". var text = ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node); - // text contains the original source, it will also contain quotes ("`"), dolar signs and braces ("${" and "}"), - // thus we need to remove those characters. - // First template piece starts with "`", others with "}" - // Last template piece ends with "`", others with "${" - var isLast = node.kind === 10 /* NoSubstitutionTemplateLiteral */ || node.kind === 13 /* TemplateTail */; + var isLast = node.kind === 10 || node.kind === 13; text = text.substring(1, text.length - (isLast ? 1 : 2)); - // Newline normalization: - // ES6 Spec 11.8.6.1 - Static Semantics of TV's and TRV's - // and LineTerminatorSequences are normalized to for both TV and TRV. text = text.replace(/\r\n?/g, "\n"); text = ts.escapeString(text); write('"' + text + '"'); } function emitDownlevelTaggedTemplateArray(node, literalEmitter) { write("["); - if (node.template.kind === 10 /* NoSubstitutionTemplateLiteral */) { + if (node.template.kind === 10) { literalEmitter(node.template); } else { @@ -25297,7 +21317,7 @@ var ts; write("]"); } function emitDownlevelTaggedTemplate(node) { - var tempVariable = createAndRecordTempVariable(0 /* Auto */); + var tempVariable = createAndRecordTempVariable(0); write("("); emit(tempVariable); write(" = "); @@ -25310,21 +21330,18 @@ var ts; emitParenthesizedIf(node.tag, needsParenthesisForPropertyAccessOrInvocation(node.tag)); write("("); emit(tempVariable); - // Now we emit the expressions - if (node.template.kind === 172 /* TemplateExpression */) { + if (node.template.kind === 172) { ts.forEach(node.template.templateSpans, function (templateSpan) { write(", "); - var needsParens = templateSpan.expression.kind === 170 /* BinaryExpression */ - && templateSpan.expression.operatorToken.kind === 23 /* CommaToken */; + var needsParens = templateSpan.expression.kind === 170 + && templateSpan.expression.operatorToken.kind === 23; emitParenthesizedIf(templateSpan.expression, needsParens); }); } write("))"); } function emitTemplateExpression(node) { - // In ES6 mode and above, we can simply emit each portion of a template in order, but in - // ES3 & ES5 we must convert the template expression into a series of string concatenations. - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { ts.forEachChild(node, emit); return; } @@ -25340,28 +21357,12 @@ var ts; } for (var i = 0, n = node.templateSpans.length; i < n; i++) { var templateSpan = node.templateSpans[i]; - // Check if the expression has operands and binds its operands less closely than binary '+'. - // If it does, we need to wrap the expression in parentheses. Otherwise, something like - // `abc${ 1 << 2 }` - // becomes - // "abc" + 1 << 2 + "" - // which is really - // ("abc" + 1) << (2 + "") - // rather than - // "abc" + (1 << 2) + "" - var needsParens = templateSpan.expression.kind !== 162 /* ParenthesizedExpression */ - && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1 /* GreaterThan */; + var needsParens = templateSpan.expression.kind !== 162 + && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; if (i > 0 || headEmitted) { - // If this is the first span and the head was not emitted, then this templateSpan's - // expression will be the first to be emitted. Don't emit the preceding ' + ' in that - // case. write(" + "); } emitParenthesizedIf(templateSpan.expression, needsParens); - // Only emit if the literal is non-empty. - // The binary '+' operator is left-associative, so the first string concatenation - // with the head will force the result up to this point to be a string. - // Emitting a '+ ""' has no semantic effect for middles and tails. if (templateSpan.literal.text.length !== 0) { write(" + "); emitLiteral(templateSpan.literal); @@ -25384,55 +21385,40 @@ var ts; // `${ foo }${ bar }` // must still be emitted as // "" + foo + bar - // There is always atleast one templateSpan in this code path, since - // NoSubstitutionTemplateLiterals are directly emitted via emitLiteral() ts.Debug.assert(node.templateSpans.length !== 0); return node.head.text.length !== 0 || node.templateSpans[0].literal.text.length === 0; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 158: + case 159: return parent.expression === template; - case 160 /* TaggedTemplateExpression */: - case 162 /* ParenthesizedExpression */: + case 160: + case 162: return false; default: - return comparePrecedenceToBinaryPlus(parent) !== -1 /* LessThan */; + return comparePrecedenceToBinaryPlus(parent) !== -1; } } - /** - * Returns whether the expression has lesser, greater, - * or equal precedence to the binary '+' operator - */ function comparePrecedenceToBinaryPlus(expression) { - // All binary expressions have lower precedence than '+' apart from '*', '/', and '%' - // which have greater precedence and '-' which has equal precedence. - // All unary operators have a higher precedence apart from yield. - // Arrow functions and conditionals have a lower precedence, - // although we convert the former into regular function expressions in ES5 mode, - // and in ES6 mode this function won't get called anyway. - // - // TODO (drosen): Note that we need to account for the upcoming 'yield' and - // spread ('...') unary operators that are anticipated for ES6. switch (expression.kind) { - case 170 /* BinaryExpression */: + case 170: switch (expression.operatorToken.kind) { - case 35 /* AsteriskToken */: - case 36 /* SlashToken */: - case 37 /* PercentToken */: - return 1 /* GreaterThan */; - case 33 /* PlusToken */: - case 34 /* MinusToken */: - return 0 /* EqualTo */; + case 35: + case 36: + case 37: + return 1; + case 33: + case 34: + return 0; default: - return -1 /* LessThan */; + return -1; } - case 173 /* YieldExpression */: - case 171 /* ConditionalExpression */: - return -1 /* LessThan */; + case 173: + case 171: + return -1; default: - return 1 /* GreaterThan */; + return 1; } } } @@ -25440,38 +21426,22 @@ var ts; emit(span.expression); emit(span.literal); } - // This function specifically handles numeric/string literals for enum and accessor 'identifiers'. - // In a sense, it does not actually emit identifiers as much as it declares a name for a specific property. - // For example, this is utilized when feeding in a result to Object.defineProperty. function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 153 /* BindingElement */); - if (node.kind === 8 /* StringLiteral */) { + ts.Debug.assert(node.kind !== 153); + if (node.kind === 8) { emitLiteral(node); } - else if (node.kind === 128 /* ComputedPropertyName */) { - // if this is a decorated computed property, we will need to capture the result - // of the property expression so that we can apply decorators later. This is to ensure - // we don't introduce unintended side effects: - // - // class C { - // [_a = x]() { } - // } - // - // The emit for the decorated computed property decorator is: - // - // Object.defineProperty(C.prototype, _a, __decorate([dec], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a))); - // + else if (node.kind === 128) { if (ts.nodeIsDecorated(node.parent)) { if (!computedPropertyNamesToGeneratedNames) { computedPropertyNamesToGeneratedNames = []; } var generatedName = computedPropertyNamesToGeneratedNames[ts.getNodeId(node)]; if (generatedName) { - // we have already generated a variable for this node, write that value instead. write(generatedName); return; } - generatedName = createAndRecordTempVariable(0 /* Auto */).text; + generatedName = createAndRecordTempVariable(0).text; computedPropertyNamesToGeneratedNames[ts.getNodeId(node)] = generatedName; write(generatedName); write(" = "); @@ -25480,7 +21450,7 @@ var ts; } else { write("\""); - if (node.kind === 7 /* NumericLiteral */) { + if (node.kind === 7) { write(node.text); } else { @@ -25492,36 +21462,36 @@ var ts; function isNotExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: + case 130: + case 199: + case 153: + case 133: + case 132: + case 225: + case 226: + case 227: + case 135: + case 134: + case 201: + case 137: + case 138: + case 163: + case 202: + case 203: + case 205: + case 206: + case 209: + case 211: + case 212: return parent.name === node; - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 214: + case 218: return parent.name === node || parent.propertyName === node; - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 215 /* ExportAssignment */: + case 191: + case 190: + case 215: return false; - case 195 /* LabeledStatement */: + case 195: return node.parent.label === node; } } @@ -25563,7 +21533,7 @@ var ts; } } function emitThis(node) { - if (resolver.getNodeCheckFlags(node) & 2 /* LexicalThis */) { + if (resolver.getNodeCheckFlags(node) & 2) { write("_this"); } else { @@ -25571,12 +21541,12 @@ var ts; } } function emitSuper(node) { - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { write("super"); } else { var flags = resolver.getNodeCheckFlags(node); - if (flags & 16 /* SuperInstance */) { + if (flags & 16) { write("_super.prototype"); } else { @@ -25617,7 +21587,7 @@ var ts; emit(node.expression); } function emitYieldExpression(node) { - write(ts.tokenToString(110 /* YieldKeyword */)); + write(ts.tokenToString(110)); if (node.asteriskToken) { write("*"); } @@ -25628,14 +21598,12 @@ var ts; } function needsParenthesisForPropertyAccessOrInvocation(node) { switch (node.kind) { - case 65 /* Identifier */: - case 154 /* ArrayLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 162 /* ParenthesizedExpression */: - // This list is not exhaustive and only includes those cases that are relevant - // to the check in emitArrayLiteral. More cases can be added as needed. + case 65: + case 154: + case 156: + case 157: + case 158: + case 162: return false; } return true; @@ -25645,7 +21613,6 @@ var ts; var group = 0; var length = elements.length; while (pos < length) { - // Emit using the pattern .concat(, , ...) if (group === 1) { write(".concat("); } @@ -25653,14 +21620,14 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 174 /* SpreadElementExpression */) { + if (e.kind === 174) { e = e.expression; emitParenthesizedIf(e, group === 0 && needsParenthesisForPropertyAccessOrInvocation(e)); pos++; } else { var i = pos; - while (i < length && elements[i].kind !== 174 /* SpreadElementExpression */) { + while (i < length && elements[i].kind !== 174) { i++; } write("["); @@ -25681,21 +21648,20 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 174 /* SpreadElementExpression */; + return node.kind === 174; } function emitArrayLiteral(node) { var elements = node.elements; if (elements.length === 0) { write("[]"); } - else if (languageVersion >= 2 /* ES6 */ || !ts.forEach(elements, isSpreadElementExpression)) { + else if (languageVersion >= 2 || !ts.forEach(elements, isSpreadElementExpression)) { write("["); emitLinePreservingList(node, node.elements, elements.hasTrailingComma, false); write("]"); } else { - emitListWithSpread(elements, (node.flags & 512 /* MultiLine */) !== 0, - /*trailingComma*/ elements.hasTrailingComma); + emitListWithSpread(elements, (node.flags & 512) !== 0, elements.hasTrailingComma); } } function emitObjectLiteralBody(node, numElements) { @@ -25706,14 +21672,11 @@ var ts; write("{"); if (numElements > 0) { var properties = node.properties; - // If we are not doing a downlevel transformation for object literals, - // then try to preserve the original shape of the object literal. - // Otherwise just try to preserve the formatting. if (numElements === properties.length) { - emitLinePreservingList(node, properties, languageVersion >= 1 /* ES5 */, true); + emitLinePreservingList(node, properties, languageVersion >= 1, true); } else { - var multiLine = (node.flags & 512 /* MultiLine */) !== 0; + var multiLine = (node.flags & 512) !== 0; if (!multiLine) { write(" "); } @@ -25732,18 +21695,13 @@ var ts; write("}"); } function emitDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex) { - var multiLine = (node.flags & 512 /* MultiLine */) !== 0; + var multiLine = (node.flags & 512) !== 0; var properties = node.properties; write("("); if (multiLine) { increaseIndent(); } - // For computed properties, we need to create a unique handle to the object - // literal so we can modify it without risking internal assignments tainting the object. - var tempVar = createAndRecordTempVariable(0 /* Auto */); - // Write out the first non-computed properties - // (or all properties if none of them are computed), - // then emit the rest through indexing on the temp variable. + var tempVar = createAndRecordTempVariable(0); emit(tempVar); write(" = "); emitObjectLiteralBody(node, firstComputedPropertyIndex); @@ -25751,8 +21709,7 @@ var ts; writeComma(); var property = properties[i]; emitStart(property); - if (property.kind === 137 /* GetAccessor */ || property.kind === 138 /* SetAccessor */) { - // TODO (drosen): Reconcile with 'emitMemberFunctions'. + if (property.kind === 137 || property.kind === 138) { var accessors = ts.getAllAccessorDeclarations(node.properties, property); if (property !== accessors.firstAccessor) { continue; @@ -25803,13 +21760,13 @@ var ts; emitMemberAccessForPropertyName(property.name); emitEnd(property.name); write(" = "); - if (property.kind === 225 /* PropertyAssignment */) { + if (property.kind === 225) { emit(property.initializer); } - else if (property.kind === 226 /* ShorthandPropertyAssignment */) { + else if (property.kind === 226) { emitExpressionIdentifier(property.name); } - else if (property.kind === 135 /* MethodDeclaration */) { + else if (property.kind === 135) { emitFunctionDeclaration(property); } else { @@ -25837,13 +21794,11 @@ var ts; } function emitObjectLiteral(node) { var properties = node.properties; - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { var numProperties = properties.length; - // Find the first computed property. - // Everything until that point can be emitted as part of the initial object literal. var numInitialNonComputedProperties = numProperties; for (var i = 0, n = properties.length; i < n; i++) { - if (properties[i].name.kind === 128 /* ComputedPropertyName */) { + if (properties[i].name.kind === 128) { numInitialNonComputedProperties = i; break; } @@ -25854,43 +21809,33 @@ var ts; return; } } - // Ordinary case: either the object has no computed properties - // or we're compiling with an ES6+ target. emitObjectLiteralBody(node, properties.length); } function createBinaryExpression(left, operator, right, startsOnNewLine) { - var result = ts.createSynthesizedNode(170 /* BinaryExpression */, startsOnNewLine); + var result = ts.createSynthesizedNode(170, startsOnNewLine); result.operatorToken = ts.createSynthesizedNode(operator); result.left = left; result.right = right; return result; } function createPropertyAccessExpression(expression, name) { - var result = ts.createSynthesizedNode(156 /* PropertyAccessExpression */); + var result = ts.createSynthesizedNode(156); result.expression = parenthesizeForAccess(expression); - result.dotToken = ts.createSynthesizedNode(20 /* DotToken */); + result.dotToken = ts.createSynthesizedNode(20); result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = ts.createSynthesizedNode(157 /* ElementAccessExpression */); + var result = ts.createSynthesizedNode(157); result.expression = parenthesizeForAccess(expression); result.argumentExpression = argumentExpression; return result; } function parenthesizeForAccess(expr) { - // isLeftHandSideExpression is almost the correct criterion for when it is not necessary - // to parenthesize the expression before a dot. The known exceptions are: - // - // NewExpression: - // new C.x -> not the same as (new C).x - // NumberLiteral - // 1.x -> not the same as (1).x - // - if (ts.isLeftHandSideExpression(expr) && expr.kind !== 159 /* NewExpression */ && expr.kind !== 7 /* NumericLiteral */) { + if (ts.isLeftHandSideExpression(expr) && expr.kind !== 159 && expr.kind !== 7) { return expr; } - var node = ts.createSynthesizedNode(162 /* ParenthesizedExpression */); + var node = ts.createSynthesizedNode(162); node.expression = expr; return node; } @@ -25900,11 +21845,11 @@ var ts; write("]"); } function emitMethod(node) { - if (languageVersion >= 2 /* ES6 */ && node.asteriskToken) { + if (languageVersion >= 2 && node.asteriskToken) { write("*"); } emit(node.name, false); - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { write(": function "); } emitSignatureAndBody(node); @@ -25916,57 +21861,38 @@ var ts; } function emitShorthandPropertyAssignment(node) { emit(node.name, false); - // If short-hand property has a prefix, then regardless of the target version, we will emit it as normal property assignment. For example: - // module m { - // export let y; - // } - // module m { - // export let obj = { y }; - // } - // The short-hand property in obj need to emit as such ... = { y : m.y } regardless of the TargetScript version - if (languageVersion < 2 /* ES6 */) { - // Emit identifier as an identifier + if (languageVersion < 2) { write(": "); var generatedName = getGeneratedNameForIdentifier(node.name); if (generatedName) { write(generatedName); } else { - // Even though this is stored as identifier treat it as an expression - // Short-hand, { x }, is equivalent of normal form { x: x } emitExpressionIdentifier(node.name); } } else if (resolver.getExpressionNameSubstitution(node.name, getGeneratedNameForNode)) { - // Emit identifier as an identifier write(": "); - // Even though this is stored as identifier treat it as an expression - // Short-hand, { x }, is equivalent of normal form { x: x } emitExpressionIdentifier(node.name); } } function tryEmitConstantValue(node) { if (compilerOptions.separateCompilation) { - // do not inline enum values in separate compilation mode return false; } var constantValue = resolver.getConstantValue(node); if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 156 /* PropertyAccessExpression */ ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 156 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; } return false; } - // Returns 'true' if the code was actually indented, false otherwise. - // If the code is not indented, an optional valueToWriteWhenNotIndenting will be - // emitted instead. function indentIfOnDifferentLines(parent, node1, node2, valueToWriteWhenNotIndenting) { var realNodesAreOnDifferentLines = !ts.nodeIsSynthesized(parent) && !nodeEndIsOnSameLineAsNodeStart(node1, node2); - // Always use a newline for synthesized code if the synthesizer desires it. var synthesizedNodeIsOnDifferentLine = synthesizedNodeStartsOnNewLine(node2); if (realNodesAreOnDifferentLines || synthesizedNodeIsOnDifferentLine) { increaseIndent(); @@ -26006,20 +21932,20 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 174 /* SpreadElementExpression */; }); + return ts.forEach(elements, function (e) { return e.kind === 174; }); } function skipParentheses(node) { - while (node.kind === 162 /* ParenthesizedExpression */ || node.kind === 161 /* TypeAssertionExpression */) { + while (node.kind === 162 || node.kind === 161) { node = node.expression; } return node; } function emitCallTarget(node) { - if (node.kind === 65 /* Identifier */ || node.kind === 93 /* ThisKeyword */ || node.kind === 91 /* SuperKeyword */) { + if (node.kind === 65 || node.kind === 93 || node.kind === 91) { emit(node); return node; } - var temp = createAndRecordTempVariable(0 /* Auto */); + var temp = createAndRecordTempVariable(0); write("("); emit(temp); write(" = "); @@ -26030,20 +21956,18 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 156 /* PropertyAccessExpression */) { - // Target will be emitted as "this" argument + if (expr.kind === 156) { target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 157 /* ElementAccessExpression */) { - // Target will be emitted as "this" argument + else if (expr.kind === 157) { target = emitCallTarget(expr.expression); write("["); emit(expr.argumentExpression); write("]"); } - else if (expr.kind === 91 /* SuperKeyword */) { + else if (expr.kind === 91) { target = expr; write("_super"); } @@ -26052,17 +21976,14 @@ var ts; } write(".apply("); if (target) { - if (target.kind === 91 /* SuperKeyword */) { - // Calls of form super(...) and super.foo(...) + if (target.kind === 91) { emitThis(target); } else { - // Calls of form obj.foo(...) emit(target); } } else { - // Calls of form foo(...) write("void 0"); } write(", "); @@ -26070,20 +21991,20 @@ var ts; write(")"); } function emitCallExpression(node) { - if (languageVersion < 2 /* ES6 */ && hasSpreadElement(node.arguments)) { + if (languageVersion < 2 && hasSpreadElement(node.arguments)) { emitCallWithSpread(node); return; } var superCall = false; - if (node.expression.kind === 91 /* SuperKeyword */) { + if (node.expression.kind === 91) { emitSuper(node.expression); superCall = true; } else { emit(node.expression); - superCall = node.expression.kind === 156 /* PropertyAccessExpression */ && node.expression.expression.kind === 91 /* SuperKeyword */; + superCall = node.expression.kind === 156 && node.expression.expression.kind === 91; } - if (superCall && languageVersion < 2 /* ES6 */) { + if (superCall && languageVersion < 2) { write(".call("); emitThis(node.expression); if (node.arguments.length) { @@ -26108,7 +22029,7 @@ var ts; } } function emitTaggedTemplateExpression(node) { - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { emit(node.tag); write(" "); emit(node.template); @@ -26118,30 +22039,20 @@ var ts; } } function emitParenExpression(node) { - if (!node.parent || node.parent.kind !== 164 /* ArrowFunction */) { - if (node.expression.kind === 161 /* TypeAssertionExpression */) { + if (!node.parent || node.parent.kind !== 164) { + if (node.expression.kind === 161) { var operand = node.expression.expression; - // Make sure we consider all nested cast expressions, e.g.: - // (-A).x; - while (operand.kind == 161 /* TypeAssertionExpression */) { + while (operand.kind == 161) { operand = operand.expression; } - // We have an expression of the form: (SubExpr) - // Emitting this as (SubExpr) is really not desirable. We would like to emit the subexpr as is. - // Omitting the parentheses, however, could cause change in the semantics of the generated - // code if the casted expression has a lower precedence than the rest of the expression, e.g.: - // (new A).foo should be emitted as (new A).foo and not new A.foo - // (typeof A).toString() should be emitted as (typeof A).toString() and not typeof A.toString() - // new (A()) should be emitted as new (A()) and not new A() - // (function foo() { })() should be emitted as an IIF (function foo(){})() and not declaration function foo(){} () - if (operand.kind !== 168 /* PrefixUnaryExpression */ && - operand.kind !== 167 /* VoidExpression */ && - operand.kind !== 166 /* TypeOfExpression */ && - operand.kind !== 165 /* DeleteExpression */ && - operand.kind !== 169 /* PostfixUnaryExpression */ && - operand.kind !== 159 /* NewExpression */ && - !(operand.kind === 158 /* CallExpression */ && node.parent.kind === 159 /* NewExpression */) && - !(operand.kind === 163 /* FunctionExpression */ && node.parent.kind === 158 /* CallExpression */)) { + if (operand.kind !== 168 && + operand.kind !== 167 && + operand.kind !== 166 && + operand.kind !== 165 && + operand.kind !== 169 && + operand.kind !== 159 && + !(operand.kind === 158 && node.parent.kind === 159) && + !(operand.kind === 163 && node.parent.kind === 158)) { emit(operand); return; } @@ -26152,25 +22063,25 @@ var ts; write(")"); } function emitDeleteExpression(node) { - write(ts.tokenToString(74 /* DeleteKeyword */)); + write(ts.tokenToString(74)); write(" "); emit(node.expression); } function emitVoidExpression(node) { - write(ts.tokenToString(99 /* VoidKeyword */)); + write(ts.tokenToString(99)); write(" "); emit(node.expression); } function emitTypeOfExpression(node) { - write(ts.tokenToString(97 /* TypeOfKeyword */)); + write(ts.tokenToString(97)); write(" "); emit(node.expression); } function isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node) { - if (!isCurrentFileSystemExternalModule() || node.kind !== 65 /* Identifier */ || ts.nodeIsSynthesized(node)) { + if (!isCurrentFileSystemExternalModule() || node.kind !== 65 || ts.nodeIsSynthesized(node)) { return false; } - var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 199 /* VariableDeclaration */ || node.parent.kind === 153 /* BindingElement */); + var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 199 || node.parent.kind === 153); var targetDeclaration = isVariableDeclarationOrBindingElement ? node.parent : resolver.getReferencedValueDeclaration(node); @@ -26179,33 +22090,17 @@ var ts; function emitPrefixUnaryExpression(node) { var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.operand); if (exportChanged) { - // emit - // ++x - // as - // exports('x', ++x) write(exportFunctionForFile + "(\""); emitNodeWithoutSourceMap(node.operand); write("\", "); } write(ts.tokenToString(node.operator)); - // In some cases, we need to emit a space between the operator and the operand. One obvious case - // is when the operator is an identifier, like delete or typeof. We also need to do this for plus - // and minus expressions in certain cases. Specifically, consider the following two cases (parens - // are just for clarity of exposition, and not part of the source code): - // - // (+(+1)) - // (+(++1)) - // - // We need to emit a space in both cases. In the first case, the absence of a space will make - // the resulting expression a prefix increment operation. And in the second, it will make the resulting - // expression a prefix increment whose operand is a plus expression - (++(+x)) - // The same is true of minus of course. - if (node.operand.kind === 168 /* PrefixUnaryExpression */) { + if (node.operand.kind === 168) { var operand = node.operand; - if (node.operator === 33 /* PlusToken */ && (operand.operator === 33 /* PlusToken */ || operand.operator === 38 /* PlusPlusToken */)) { + if (node.operator === 33 && (operand.operator === 33 || operand.operator === 38)) { write(" "); } - else if (node.operator === 34 /* MinusToken */ && (operand.operator === 34 /* MinusToken */ || operand.operator === 39 /* MinusMinusToken */)) { + else if (node.operator === 34 && (operand.operator === 34 || operand.operator === 39)) { write(" "); } } @@ -26217,15 +22112,12 @@ var ts; function emitPostfixUnaryExpression(node) { var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.operand); if (exportChanged) { - // export function returns the value that was passes as the second argument - // however for postfix unary expressions result value should be the value before modification. - // emit 'x++' as '(export('x', ++x) - 1)' and 'x--' as '(export('x', --x) + 1)' write("(" + exportFunctionForFile + "(\""); emitNodeWithoutSourceMap(node.operand); write("\", "); write(ts.tokenToString(node.operator)); emit(node.operand); - if (node.operator === 38 /* PlusPlusToken */) { + if (node.operator === 38) { write(") - 1)"); } else { @@ -26240,26 +22132,16 @@ var ts; function shouldHoistDeclarationInSystemJsModule(node) { return isSourceFileLevelDeclarationInSystemJsModule(node, false); } - /* - * Checks if given node is a source file level declaration (not nested in module/function). - * If 'isExported' is true - then declaration must also be exported. - * This function is used in two cases: - * - check if node is a exported source file level value to determine - * if we should also export the value after its it changed - * - check if node is a source level declaration to emit it differently, - * i.e non-exported variable statement 'var x = 1' is hoisted so - * we we emit variable statement 'var' should be dropped. - */ function isSourceFileLevelDeclarationInSystemJsModule(node, isExported) { - if (!node || languageVersion >= 2 /* ES6 */ || !isCurrentFileSystemExternalModule()) { + if (!node || languageVersion >= 2 || !isCurrentFileSystemExternalModule()) { return false; } var current = node; while (current) { - if (current.kind === 228 /* SourceFile */) { - return !isExported || ((ts.getCombinedNodeFlags(node) & 1 /* Export */) !== 0); + if (current.kind === 228) { + return !isExported || ((ts.getCombinedNodeFlags(node) & 1) !== 0); } - else if (ts.isFunctionLike(current) || current.kind === 207 /* ModuleBlock */) { + else if (ts.isFunctionLike(current) || current.kind === 207) { return false; } else { @@ -26268,22 +22150,21 @@ var ts; } } function emitBinaryExpression(node) { - if (languageVersion < 2 /* ES6 */ && node.operatorToken.kind === 53 /* EqualsToken */ && - (node.left.kind === 155 /* ObjectLiteralExpression */ || node.left.kind === 154 /* ArrayLiteralExpression */)) { - emitDestructuring(node, node.parent.kind === 183 /* ExpressionStatement */); + if (languageVersion < 2 && node.operatorToken.kind === 53 && + (node.left.kind === 155 || node.left.kind === 154)) { + emitDestructuring(node, node.parent.kind === 183); } else { - var exportChanged = node.operatorToken.kind >= 53 /* FirstAssignment */ && - node.operatorToken.kind <= 64 /* LastAssignment */ && + var exportChanged = node.operatorToken.kind >= 53 && + node.operatorToken.kind <= 64 && isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.left); if (exportChanged) { - // emit assignment 'x y' as 'exports("x", x y)' write(exportFunctionForFile + "(\""); emitNodeWithoutSourceMap(node.left); write("\", "); } emit(node.left); - var indentedBeforeOperator = indentIfOnDifferentLines(node, node.left, node.operatorToken, node.operatorToken.kind !== 23 /* CommaToken */ ? " " : undefined); + var indentedBeforeOperator = indentIfOnDifferentLines(node, node.left, node.operatorToken, node.operatorToken.kind !== 23 ? " " : undefined); write(ts.tokenToString(node.operatorToken.kind)); var indentedAfterOperator = indentIfOnDifferentLines(node, node.operatorToken, node.right, " "); emit(node.right); @@ -26309,10 +22190,6 @@ var ts; emit(node.whenFalse); decreaseIndentIf(indentedBeforeColon, indentedAfterColon); } - // Helper function to decrease the indent if we previously indented. Allows multiple - // previous indent values to be considered at a time. This also allows caller to just - // call this once, passing in all their appropriate indent values, instead of needing - // to call this helper function multiple times. function decreaseIndentIf(value1, value2) { if (value1) { decreaseIndent(); @@ -26322,36 +22199,36 @@ var ts; } } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 180 /* Block */) { + if (node && node.kind === 180) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } } function emitBlock(node) { if (isSingleLineEmptyBlock(node)) { - emitToken(14 /* OpenBraceToken */, node.pos); + emitToken(14, node.pos); write(" "); - emitToken(15 /* CloseBraceToken */, node.statements.end); + emitToken(15, node.statements.end); return; } - emitToken(14 /* OpenBraceToken */, node.pos); + emitToken(14, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 207 /* ModuleBlock */) { - ts.Debug.assert(node.parent.kind === 206 /* ModuleDeclaration */); + if (node.kind === 207) { + ts.Debug.assert(node.parent.kind === 206); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 207 /* ModuleBlock */) { + if (node.kind === 207) { emitTempDeclarations(true); } decreaseIndent(); writeLine(); - emitToken(15 /* CloseBraceToken */, node.statements.end); + emitToken(15, node.statements.end); scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 180 /* Block */) { + if (node.kind === 180) { write(" "); emit(node); } @@ -26363,20 +22240,20 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesizedIf(node.expression, node.expression.kind === 164 /* ArrowFunction */); + emitParenthesizedIf(node.expression, node.expression.kind === 164); write(";"); } function emitIfStatement(node) { - var endPos = emitToken(84 /* IfKeyword */, node.pos); + var endPos = emitToken(84, node.pos); write(" "); - endPos = emitToken(16 /* OpenParenToken */, endPos); + endPos = emitToken(16, endPos); emit(node.expression); - emitToken(17 /* CloseParenToken */, node.expression.end); + emitToken(17, node.expression.end); emitEmbeddedStatement(node.thenStatement); if (node.elseStatement) { writeLine(); - emitToken(76 /* ElseKeyword */, node.thenStatement.end); - if (node.elseStatement.kind === 184 /* IfStatement */) { + emitToken(76, node.thenStatement.end); + if (node.elseStatement.kind === 184) { write(" "); emit(node.elseStatement); } @@ -26388,7 +22265,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 180 /* Block */) { + if (node.statement.kind === 180) { write(" "); } else { @@ -26404,22 +22281,17 @@ var ts; write(")"); emitEmbeddedStatement(node.statement); } - /* Returns true if start of variable declaration list was emitted. - * Return false if nothing was written - this can happen for source file level variable declarations - * in system modules - such variable declarations are hoisted. - */ function tryEmitStartOfVariableDeclarationList(decl, startPos) { if (shouldHoistVariable(decl, true)) { - // variables in variable declaration list were already hoisted return false; } - var tokenKind = 98 /* VarKeyword */; - if (decl && languageVersion >= 2 /* ES6 */) { + var tokenKind = 98; + if (decl && languageVersion >= 2) { if (ts.isLet(decl)) { - tokenKind = 104 /* LetKeyword */; + tokenKind = 104; } else if (ts.isConst(decl)) { - tokenKind = 70 /* ConstKeyword */; + tokenKind = 70; } } if (startPos !== undefined) { @@ -26428,13 +22300,13 @@ var ts; } else { switch (tokenKind) { - case 98 /* VarKeyword */: + case 98: write("var "); break; - case 104 /* LetKeyword */: + case 104: write("let "); break; - case 70 /* ConstKeyword */: + case 70: write("const "); break; } @@ -26459,10 +22331,10 @@ var ts; return started; } function emitForStatement(node) { - var endPos = emitToken(82 /* ForKeyword */, node.pos); + var endPos = emitToken(82, node.pos); write(" "); - endPos = emitToken(16 /* OpenParenToken */, endPos); - if (node.initializer && node.initializer.kind === 200 /* VariableDeclarationList */) { + endPos = emitToken(16, endPos); + if (node.initializer && node.initializer.kind === 200) { var variableDeclarationList = node.initializer; var startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); if (startIsEmitted) { @@ -26483,13 +22355,13 @@ var ts; emitEmbeddedStatement(node.statement); } function emitForInOrForOfStatement(node) { - if (languageVersion < 2 /* ES6 */ && node.kind === 189 /* ForOfStatement */) { + if (languageVersion < 2 && node.kind === 189) { return emitDownLevelForOfStatement(node); } - var endPos = emitToken(82 /* ForKeyword */, node.pos); + var endPos = emitToken(82, node.pos); write(" "); - endPos = emitToken(16 /* OpenParenToken */, endPos); - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + endPos = emitToken(16, endPos); + if (node.initializer.kind === 200) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); @@ -26499,14 +22371,14 @@ var ts; else { emit(node.initializer); } - if (node.kind === 188 /* ForInStatement */) { + if (node.kind === 188) { write(" in "); } else { write(" of "); } emit(node.expression); - emitToken(17 /* CloseParenToken */, node.expression.end); + emitToken(17, node.expression.end); emitEmbeddedStatement(node.statement); } function emitDownLevelForOfStatement(node) { @@ -26530,30 +22402,18 @@ var ts; // all destructuring. // Note also that because an extra statement is needed to assign to the LHS, // for-of bodies are always emitted as blocks. - var endPos = emitToken(82 /* ForKeyword */, node.pos); + var endPos = emitToken(82, node.pos); write(" "); - endPos = emitToken(16 /* OpenParenToken */, endPos); - // Do not emit the LHS let declaration yet, because it might contain destructuring. - // Do not call recordTempDeclaration because we are declaring the temps - // right here. Recording means they will be declared later. - // In the case where the user wrote an identifier as the RHS, like this: - // - // for (let v of arr) { } - // - // we don't want to emit a temporary variable for the RHS, just use it directly. - var rhsIsIdentifier = node.expression.kind === 65 /* Identifier */; - var counter = createTempVariable(268435456 /* _i */); - var rhsReference = rhsIsIdentifier ? node.expression : createTempVariable(0 /* Auto */); - // This is the let keyword for the counter and rhsReference. The let keyword for - // the LHS will be emitted inside the body. + endPos = emitToken(16, endPos); + var rhsIsIdentifier = node.expression.kind === 65; + var counter = createTempVariable(268435456); + var rhsReference = rhsIsIdentifier ? node.expression : createTempVariable(0); emitStart(node.expression); write("var "); - // _i = 0 emitNodeWithoutSourceMap(counter); write(" = 0"); emitEnd(node.expression); if (!rhsIsIdentifier) { - // , _a = expr write(", "); emitStart(node.expression); emitNodeWithoutSourceMap(rhsReference); @@ -26562,7 +22422,6 @@ var ts; emitEnd(node.expression); } write("; "); - // _i < _a.length; emitStart(node.initializer); emitNodeWithoutSourceMap(counter); write(" < "); @@ -26570,53 +22429,39 @@ var ts; write(".length"); emitEnd(node.initializer); write("; "); - // _i++) emitStart(node.initializer); emitNodeWithoutSourceMap(counter); write("++"); emitEnd(node.initializer); - emitToken(17 /* CloseParenToken */, node.expression.end); - // Body + emitToken(17, node.expression.end); write(" {"); writeLine(); increaseIndent(); - // Initialize LHS - // let v = _a[_i]; var rhsIterationValue = createElementAccessExpression(rhsReference, counter); emitStart(node.initializer); - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 200) { write("var "); var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length > 0) { var declaration = variableDeclarationList.declarations[0]; if (ts.isBindingPattern(declaration.name)) { - // This works whether the declaration is a var, let, or const. - // It will use rhsIterationValue _a[_i] as the initializer. emitDestructuring(declaration, false, rhsIterationValue); } else { - // The following call does not include the initializer, so we have - // to emit it separately. emitNodeWithoutSourceMap(declaration); write(" = "); emitNodeWithoutSourceMap(rhsIterationValue); } } else { - // It's an empty declaration list. This can only happen in an error case, if the user wrote - // for (let of []) {} - emitNodeWithoutSourceMap(createTempVariable(0 /* Auto */)); + emitNodeWithoutSourceMap(createTempVariable(0)); write(" = "); emitNodeWithoutSourceMap(rhsIterationValue); } } else { - // Initializer is an expression. Emit the expression in the body, so that it's - // evaluated on every iteration. - var assignmentExpression = createBinaryExpression(node.initializer, 53 /* EqualsToken */, rhsIterationValue, false); - if (node.initializer.kind === 154 /* ArrayLiteralExpression */ || node.initializer.kind === 155 /* ObjectLiteralExpression */) { - // This is a destructuring pattern, so call emitDestructuring instead of emit. Calling emit will not work, because it will cause - // the BinaryExpression to be passed in instead of the expression statement, which will cause emitDestructuring to crash. + var assignmentExpression = createBinaryExpression(node.initializer, 53, rhsIterationValue, false); + if (node.initializer.kind === 154 || node.initializer.kind === 155) { emitDestructuring(assignmentExpression, true, undefined); } else { @@ -26625,7 +22470,7 @@ var ts; } emitEnd(node.initializer); write(";"); - if (node.statement.kind === 180 /* Block */) { + if (node.statement.kind === 180) { emitLines(node.statement.statements); } else { @@ -26637,12 +22482,12 @@ var ts; write("}"); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 191 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */, node.pos); + emitToken(node.kind === 191 ? 66 : 71, node.pos); emitOptional(" ", node.label); write(";"); } function emitReturnStatement(node) { - emitToken(90 /* ReturnKeyword */, node.pos); + emitToken(90, node.pos); emitOptional(" ", node.expression); write(";"); } @@ -26653,21 +22498,21 @@ var ts; emitEmbeddedStatement(node.statement); } function emitSwitchStatement(node) { - var endPos = emitToken(92 /* SwitchKeyword */, node.pos); + var endPos = emitToken(92, node.pos); write(" "); - emitToken(16 /* OpenParenToken */, endPos); + emitToken(16, endPos); emit(node.expression); - endPos = emitToken(17 /* CloseParenToken */, node.expression.end); + endPos = emitToken(17, node.expression.end); write(" "); emitCaseBlock(node.caseBlock, endPos); } function emitCaseBlock(node, startPos) { - emitToken(14 /* OpenBraceToken */, startPos); + emitToken(14, startPos); increaseIndent(); emitLines(node.clauses); decreaseIndent(); writeLine(); - emitToken(15 /* CloseBraceToken */, node.clauses.end); + emitToken(15, node.clauses.end); } function nodeStartPositionsAreOnSameLine(node1, node2) { return ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node1.pos)) === @@ -26682,7 +22527,7 @@ var ts; ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 221 /* CaseClause */) { + if (node.kind === 221) { write("case "); emit(node.expression); write(":"); @@ -26717,16 +22562,16 @@ var ts; } function emitCatchClause(node) { writeLine(); - var endPos = emitToken(68 /* CatchKeyword */, node.pos); + var endPos = emitToken(68, node.pos); write(" "); - emitToken(16 /* OpenParenToken */, endPos); + emitToken(16, endPos); emit(node.variableDeclaration); - emitToken(17 /* CloseParenToken */, node.variableDeclaration ? node.variableDeclaration.end : endPos); + emitToken(17, node.variableDeclaration ? node.variableDeclaration.end : endPos); write(" "); emitBlock(node.block); } function emitDebuggerStatement(node) { - emitToken(72 /* DebuggerKeyword */, node.pos); + emitToken(72, node.pos); write(";"); } function emitLabelledStatement(node) { @@ -26737,7 +22582,7 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 206 /* ModuleDeclaration */); + } while (node && node.kind !== 206); return node; } function emitContainingModuleName(node) { @@ -26746,13 +22591,13 @@ var ts; } function emitModuleMemberName(node) { emitStart(node.name); - if (ts.getCombinedNodeFlags(node) & 1 /* Export */) { + if (ts.getCombinedNodeFlags(node) & 1) { var container = getContainingModule(node); if (container) { write(getGeneratedNameForNode(container)); write("."); } - else if (languageVersion < 2 /* ES6 */ && compilerOptions.module !== 4 /* System */) { + else if (languageVersion < 2 && compilerOptions.module !== 4) { write("exports."); } } @@ -26760,21 +22605,19 @@ var ts; emitEnd(node.name); } function createVoidZero() { - var zero = ts.createSynthesizedNode(7 /* NumericLiteral */); + var zero = ts.createSynthesizedNode(7); zero.text = "0"; - var result = ts.createSynthesizedNode(167 /* VoidExpression */); + var result = ts.createSynthesizedNode(167); result.expression = zero; return result; } function emitExportMemberAssignment(node) { - if (node.flags & 1 /* Export */) { + if (node.flags & 1) { writeLine(); emitStart(node); - if (compilerOptions.module === 4 /* System */) { - // emit export default as - // export("default", ) + if (compilerOptions.module === 4) { write(exportFunctionForFile + "(\""); - if (node.flags & 256 /* Default */) { + if (node.flags & 256) { write("default"); } else { @@ -26785,8 +22628,8 @@ var ts; write(")"); } else { - if (node.flags & 256 /* Default */) { - if (languageVersion === 0 /* ES3 */) { + if (node.flags & 256) { + if (languageVersion === 0) { write("exports[\"default\"]"); } else { @@ -26808,7 +22651,7 @@ var ts; for (var _a = 0, _b = exportSpecifiers[name.text]; _a < _b.length; _a++) { var specifier = _b[_a]; writeLine(); - if (compilerOptions.module === 4 /* System */) { + if (compilerOptions.module === 4) { emitStart(specifier.name); write(exportFunctionForFile + "(\""); emitNodeWithoutSourceMap(specifier.name); @@ -26832,20 +22675,16 @@ var ts; } function emitDestructuring(root, isAssignmentExpressionStatement, value) { var emitCount = 0; - // An exported declaration is actually emitted as an assignment (to a property on the module object), so - // temporary variables in an exported declaration need to have real declarations elsewhere - // Also temporary variables should be explicitly allocated for source level declarations when module target is system - // because actual variable declarations are hoisted var canDefineTempVariablesInPlace = false; - if (root.kind === 199 /* VariableDeclaration */) { - var isExported = ts.getCombinedNodeFlags(root) & 1 /* Export */; + if (root.kind === 199) { + var isExported = ts.getCombinedNodeFlags(root) & 1; var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root); canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind; } - else if (root.kind === 130 /* Parameter */) { + else if (root.kind === 130) { canDefineTempVariablesInPlace = true; } - if (root.kind === 170 /* BinaryExpression */) { + if (root.kind === 170) { emitAssignmentExpression(root); } else { @@ -26857,7 +22696,7 @@ var ts; write(", "); } renameNonTopLevelLetAndConst(name); - var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 199 /* VariableDeclaration */ || name.parent.kind === 153 /* BindingElement */); + var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 199 || name.parent.kind === 153); var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name); if (exportChanged) { write(exportFunctionForFile + "(\""); @@ -26877,8 +22716,8 @@ var ts; } } function ensureIdentifier(expr) { - if (expr.kind !== 65 /* Identifier */) { - var identifier = createTempVariable(0 /* Auto */); + if (expr.kind !== 65) { + var identifier = createTempVariable(0); if (!canDefineTempVariablesInPlace) { recordTempDeclaration(identifier); } @@ -26888,39 +22727,36 @@ var ts; return expr; } function createDefaultValueCheck(value, defaultValue) { - // The value expression will be evaluated twice, so for anything but a simple identifier - // we need to generate a temporary variable value = ensureIdentifier(value); - // Return the expression 'value === void 0 ? defaultValue : value' - var equals = ts.createSynthesizedNode(170 /* BinaryExpression */); + var equals = ts.createSynthesizedNode(170); equals.left = value; - equals.operatorToken = ts.createSynthesizedNode(30 /* EqualsEqualsEqualsToken */); + equals.operatorToken = ts.createSynthesizedNode(30); equals.right = createVoidZero(); return createConditionalExpression(equals, defaultValue, value); } function createConditionalExpression(condition, whenTrue, whenFalse) { - var cond = ts.createSynthesizedNode(171 /* ConditionalExpression */); + var cond = ts.createSynthesizedNode(171); cond.condition = condition; - cond.questionToken = ts.createSynthesizedNode(50 /* QuestionToken */); + cond.questionToken = ts.createSynthesizedNode(50); cond.whenTrue = whenTrue; - cond.colonToken = ts.createSynthesizedNode(51 /* ColonToken */); + cond.colonToken = ts.createSynthesizedNode(51); cond.whenFalse = whenFalse; return cond; } function createNumericLiteral(value) { - var node = ts.createSynthesizedNode(7 /* NumericLiteral */); + var node = ts.createSynthesizedNode(7); node.text = "" + value; return node; } function createPropertyAccessForDestructuringProperty(object, propName) { - if (propName.kind !== 65 /* Identifier */) { + if (propName.kind !== 65) { return createElementAccessExpression(object, propName); } return createPropertyAccessExpression(object, propName); } function createSliceCall(value, sliceIndex) { - var call = ts.createSynthesizedNode(158 /* CallExpression */); - var sliceIdentifier = ts.createSynthesizedNode(65 /* Identifier */); + var call = ts.createSynthesizedNode(158); + var sliceIdentifier = ts.createSynthesizedNode(65); sliceIdentifier.text = "slice"; call.expression = createPropertyAccessExpression(value, sliceIdentifier); call.arguments = ts.createSynthesizedNodeArray(); @@ -26930,14 +22766,11 @@ var ts; function emitObjectLiteralAssignment(target, value) { var properties = target.properties; if (properties.length !== 1) { - // For anything but a single element destructuring we need to generate a temporary - // to ensure value is evaluated exactly once. value = ensureIdentifier(value); } for (var _a = 0; _a < properties.length; _a++) { var p = properties[_a]; - if (p.kind === 225 /* PropertyAssignment */ || p.kind === 226 /* ShorthandPropertyAssignment */) { - // TODO(andersh): Computed property support + if (p.kind === 225 || p.kind === 226) { var propName = (p.name); emitDestructuringAssignment(p.initializer || propName, createPropertyAccessForDestructuringProperty(value, propName)); } @@ -26946,14 +22779,12 @@ var ts; function emitArrayLiteralAssignment(target, value) { var elements = target.elements; if (elements.length !== 1) { - // For anything but a single element destructuring we need to generate a temporary - // to ensure value is evaluated exactly once. value = ensureIdentifier(value); } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176 /* OmittedExpression */) { - if (e.kind !== 174 /* SpreadElementExpression */) { + if (e.kind !== 176) { + if (e.kind !== 174) { emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i))); } else if (i === elements.length - 1) { @@ -26963,14 +22794,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 170 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { + if (target.kind === 170 && target.operatorToken.kind === 53) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 155 /* ObjectLiteralExpression */) { + if (target.kind === 155) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 154 /* ArrayLiteralExpression */) { + else if (target.kind === 154) { emitArrayLiteralAssignment(target, value); } else { @@ -26984,45 +22815,39 @@ var ts; emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 162 /* ParenthesizedExpression */) { + if (root.parent.kind !== 162) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 162 /* ParenthesizedExpression */) { + if (root.parent.kind !== 162) { write(")"); } } } function emitBindingElement(target, value) { if (target.initializer) { - // Combine value and initializer value = value ? createDefaultValueCheck(value, target.initializer) : target.initializer; } else if (!value) { - // Use 'void 0' in absence of value and initializer value = createVoidZero(); } if (ts.isBindingPattern(target.name)) { var pattern = target.name; var elements = pattern.elements; if (elements.length !== 1) { - // For anything but a single element destructuring we need to generate a temporary - // to ensure value is evaluated exactly once. value = ensureIdentifier(value); } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 151 /* ObjectBindingPattern */) { - // Rewrite element to a declaration with an initializer that fetches property + if (pattern.kind === 151) { var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName)); } - else if (element.kind !== 176 /* OmittedExpression */) { + else if (element.kind !== 176) { if (!element.dotDotDotToken) { - // Rewrite element to a declaration that accesses array element at index i emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i))); } else if (i === elements.length - 1) { @@ -27038,7 +22863,7 @@ var ts; } function emitVariableDeclaration(node) { if (ts.isBindingPattern(node.name)) { - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { emitDestructuring(node, false); } else { @@ -27049,19 +22874,12 @@ var ts; else { renameNonTopLevelLetAndConst(node.name); var initializer = node.initializer; - if (!initializer && languageVersion < 2 /* ES6 */) { - // downlevel emit for non-initialized let bindings defined in loops - // for (...) { let x; } - // should be - // for (...) { var = void 0; } - // this is necessary to preserve ES6 semantic in scenarios like - // for (...) { let x; console.log(x); x = 1 } // assignment on one iteration should not affect other iterations - var isUninitializedLet = (resolver.getNodeCheckFlags(node) & 256 /* BlockScopedBindingInLoop */) && - (getCombinedFlagsForIdentifier(node.name) & 4096 /* Let */); - // NOTE: default initialization should not be added to let bindings in for-in\for-of statements + if (!initializer && languageVersion < 2) { + var isUninitializedLet = (resolver.getNodeCheckFlags(node) & 256) && + (getCombinedFlagsForIdentifier(node.name) & 4096); if (isUninitializedLet && - node.parent.parent.kind !== 188 /* ForInStatement */ && - node.parent.parent.kind !== 189 /* ForOfStatement */) { + node.parent.parent.kind !== 188 && + node.parent.parent.kind !== 189) { initializer = createVoidZero(); } } @@ -27079,11 +22897,11 @@ var ts; } } function emitExportVariableAssignments(node) { - if (node.kind === 176 /* OmittedExpression */) { + if (node.kind === 176) { return; } var name = node.name; - if (name.kind === 65 /* Identifier */) { + if (name.kind === 65) { emitExportMemberAssignments(name); } else if (ts.isBindingPattern(name)) { @@ -27091,41 +22909,33 @@ var ts; } } function getCombinedFlagsForIdentifier(node) { - if (!node.parent || (node.parent.kind !== 199 /* VariableDeclaration */ && node.parent.kind !== 153 /* BindingElement */)) { + if (!node.parent || (node.parent.kind !== 199 && node.parent.kind !== 153)) { return 0; } return ts.getCombinedNodeFlags(node.parent); } function renameNonTopLevelLetAndConst(node) { - // do not rename if - // - language version is ES6+ - // - node is synthesized - // - node is not identifier (can happen when tree is malformed) - // - node is definitely not name of variable declaration. - // it still can be part of parameter declaration, this check will be done next - if (languageVersion >= 2 /* ES6 */ || + if (languageVersion >= 2 || ts.nodeIsSynthesized(node) || - node.kind !== 65 /* Identifier */ || - (node.parent.kind !== 199 /* VariableDeclaration */ && node.parent.kind !== 153 /* BindingElement */)) { + node.kind !== 65 || + (node.parent.kind !== 199 && node.parent.kind !== 153)) { return; } var combinedFlags = getCombinedFlagsForIdentifier(node); - if (((combinedFlags & 12288 /* BlockScoped */) === 0) || combinedFlags & 1 /* Export */) { - // do not rename exported or non-block scoped variables + if (((combinedFlags & 12288) === 0) || combinedFlags & 1) { return; } - // here it is known that node is a block scoped variable - var list = ts.getAncestor(node, 200 /* VariableDeclarationList */); - if (list.parent.kind === 181 /* VariableStatement */) { - var isSourceFileLevelBinding = list.parent.parent.kind === 228 /* SourceFile */; - var isModuleLevelBinding = list.parent.parent.kind === 207 /* ModuleBlock */; - var isFunctionLevelBinding = list.parent.parent.kind === 180 /* Block */ && ts.isFunctionLike(list.parent.parent.parent); + var list = ts.getAncestor(node, 200); + if (list.parent.kind === 181) { + var isSourceFileLevelBinding = list.parent.parent.kind === 228; + var isModuleLevelBinding = list.parent.parent.kind === 207; + var isFunctionLevelBinding = list.parent.parent.kind === 180 && ts.isFunctionLike(list.parent.parent.parent); if (isSourceFileLevelBinding || isModuleLevelBinding || isFunctionLevelBinding) { return; } } var blockScopeContainer = ts.getEnclosingBlockScopeContainer(node); - var parent = blockScopeContainer.kind === 228 /* SourceFile */ + var parent = blockScopeContainer.kind === 228 ? blockScopeContainer : blockScopeContainer.parent; if (resolver.resolvesToSomeValue(parent, node.text)) { @@ -27138,17 +22948,16 @@ var ts; } } function isES6ExportedDeclaration(node) { - return !!(node.flags & 1 /* Export */) && - languageVersion >= 2 /* ES6 */ && - node.parent.kind === 228 /* SourceFile */; + return !!(node.flags & 1) && + languageVersion >= 2 && + node.parent.kind === 228; } function emitVariableStatement(node) { var startIsEmitted = true; - if (!(node.flags & 1 /* Export */)) { + if (!(node.flags & 1)) { startIsEmitted = tryEmitStartOfVariableDeclarationList(node.declarationList); } else if (isES6ExportedDeclaration(node)) { - // Exported ES6 module member write("export "); startIsEmitted = tryEmitStartOfVariableDeclarationList(node.declarationList); } @@ -27162,14 +22971,14 @@ var ts; write(";"); } } - if (languageVersion < 2 /* ES6 */ && node.parent === currentSourceFile) { + if (languageVersion < 2 && node.parent === currentSourceFile) { ts.forEach(node.declarationList.declarations, emitExportVariableAssignments); } } function emitParameter(node) { - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { if (ts.isBindingPattern(node.name)) { - var name_19 = createTempVariable(0 /* Auto */); + var name_19 = createTempVariable(0); if (!tempParameters) { tempParameters = []; } @@ -27189,11 +22998,9 @@ var ts; } } function emitDefaultValueAssignments(node) { - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { var tempIndex = 0; ts.forEach(node.parameters, function (p) { - // A rest parameter cannot have a binding pattern or an initializer, - // so let's just ignore it. if (p.dotDotDotToken) { return; } @@ -27223,14 +23030,13 @@ var ts; } } function emitRestParameter(node) { - if (languageVersion < 2 /* ES6 */ && ts.hasRestParameters(node)) { + if (languageVersion < 2 && ts.hasRestParameters(node)) { var restIndex = node.parameters.length - 1; var restParam = node.parameters[restIndex]; - // A rest parameter cannot have a binding pattern, so let's just ignore it if it does. if (ts.isBindingPattern(restParam.name)) { return; } - var tempName = createTempVariable(268435456 /* _i */).text; + var tempName = createTempVariable(268435456).text; writeLine(); emitLeadingComments(restParam); emitStart(restParam); @@ -27265,12 +23071,12 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 137 /* GetAccessor */ ? "get " : "set "); + write(node.kind === 137 ? "get " : "set "); emit(node.name, false); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 164 /* ArrowFunction */ && languageVersion >= 2 /* ES6 */; + return node.kind === 164 && languageVersion >= 2; } function emitDeclarationName(node) { if (node.name) { @@ -27281,34 +23087,29 @@ var ts; } } function shouldEmitFunctionName(node) { - if (node.kind === 163 /* FunctionExpression */) { - // Emit name if one is present + if (node.kind === 163) { return !!node.name; } - if (node.kind === 201 /* FunctionDeclaration */) { - // Emit name if one is present, or emit generated name in down-level case (for export default case) - return !!node.name || languageVersion < 2 /* ES6 */; + if (node.kind === 201) { + return !!node.name || languageVersion < 2; } } function emitFunctionDeclaration(node) { if (ts.nodeIsMissing(node.body)) { return emitOnlyPinnedOrTripleSlashComments(node); } - if (node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { - // Methods will emit the comments as part of emitting method declaration + if (node.kind !== 135 && node.kind !== 134) { emitLeadingComments(node); } - // For targeting below es6, emit functions-like declaration including arrow function using function keyword. - // When targeting ES6, emit arrow function natively in ES6 by omitting function keyword and using fat arrow instead if (!shouldEmitAsArrowFunction(node)) { if (isES6ExportedDeclaration(node)) { write("export "); - if (node.flags & 256 /* Default */) { + if (node.flags & 256) { write("default "); } } write("function"); - if (languageVersion >= 2 /* ES6 */ && node.asteriskToken) { + if (languageVersion >= 2 && node.asteriskToken) { write("*"); } write(" "); @@ -27317,15 +23118,15 @@ var ts; emitDeclarationName(node); } emitSignatureAndBody(node); - if (languageVersion < 2 /* ES6 */ && node.kind === 201 /* FunctionDeclaration */ && node.parent === currentSourceFile && node.name) { + if (languageVersion < 2 && node.kind === 201 && node.parent === currentSourceFile && node.name) { emitExportMemberAssignments(node.name); } - if (node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (node.kind !== 135 && node.kind !== 134) { emitTrailingComments(node); } } function emitCaptureThisForNodeIfNecessary(node) { - if (resolver.getNodeCheckFlags(node) & 4 /* CaptureThis */) { + if (resolver.getNodeCheckFlags(node) & 4) { writeLine(); emitStart(node); write("var _this = this;"); @@ -27337,14 +23138,13 @@ var ts; write("("); if (node) { var parameters = node.parameters; - var omitCount = languageVersion < 2 /* ES6 */ && ts.hasRestParameters(node) ? 1 : 0; + var omitCount = languageVersion < 2 && ts.hasRestParameters(node) ? 1 : 0; emitList(parameters, 0, parameters.length - omitCount, false, false); } write(")"); decreaseIndent(); } function emitSignatureParametersForArrow(node) { - // Check whether the parameter list needs parentheses and preserve no-parenthesis if (node.parameters.length === 1 && node.pos === node.parameters[0].pos) { emit(node.parameters[0]); return; @@ -27358,7 +23158,6 @@ var ts; tempFlags = 0; tempVariables = undefined; tempParameters = undefined; - // When targeting ES6, emit arrow function natively in ES6 if (shouldEmitAsArrowFunction(node)) { emitSignatureParametersForArrow(node); write(" =>"); @@ -27367,11 +23166,9 @@ var ts; emitSignatureParameters(node); } if (!node.body) { - // There can be no body when there are parse errors. Just emit an empty block - // in that case. write(" { }"); } - else if (node.body.kind === 180 /* Block */) { + else if (node.body.kind === 180) { emitBlockFunctionBody(node, node.body); } else { @@ -27384,28 +23181,22 @@ var ts; tempVariables = saveTempVariables; tempParameters = saveTempParameters; } - // Returns true if any preamble code was emitted. function emitFunctionBodyPreamble(node) { emitCaptureThisForNodeIfNecessary(node); emitDefaultValueAssignments(node); emitRestParameter(node); } function emitExpressionFunctionBody(node, body) { - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { emitDownLevelExpressionFunctionBody(node, body); return; } - // For es6 and higher we can emit the expression as is. However, in the case - // where the expression might end up looking like a block when emitted, we'll - // also wrap it in parentheses first. For example if you have: a => {} - // then we need to generate: a => ({}) write(" "); - // Unwrap all type assertions. var current = body; - while (current.kind === 161 /* TypeAssertionExpression */) { + while (current.kind === 161) { current = current.expression; } - emitParenthesizedIf(body, current.kind === 155 /* ObjectLiteralExpression */); + emitParenthesizedIf(body, current.kind === 155); } function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); @@ -27416,8 +23207,6 @@ var ts; emitFunctionBodyPreamble(node); var preambleEmitted = writer.getTextPos() !== outPos; decreaseIndent(); - // If we didn't have to emit any preamble code, then attempt to keep the arrow - // function on one line. if (!preambleEmitted && nodeStartPositionsAreOnSameLine(node, body)) { write(" "); emitStart(body); @@ -27451,8 +23240,6 @@ var ts; var initialTextPos = writer.getTextPos(); increaseIndent(); emitDetachedComments(body.statements); - // Emit all the directive prologues (like "use strict"). These have to come before - // any other preamble code we write (like parameter initializers). var startIndex = emitDirectivePrologues(body.statements, true); emitFunctionBodyPreamble(node); decreaseIndent(); @@ -27475,17 +23262,17 @@ var ts; emitLeadingCommentsOfPosition(body.statements.end); decreaseIndent(); } - emitToken(15 /* CloseBraceToken */, body.statements.end); + emitToken(15, body.statements.end); scopeEmitEnd(); } function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 183 /* ExpressionStatement */) { + if (statement && statement.kind === 183) { var expr = statement.expression; - if (expr && expr.kind === 158 /* CallExpression */) { + if (expr && expr.kind === 158) { var func = expr.expression; - if (func && func.kind === 91 /* SuperKeyword */) { + if (func && func.kind === 91) { return statement; } } @@ -27494,7 +23281,7 @@ var ts; } function emitParameterPropertyAssignments(node) { ts.forEach(node.parameters, function (param) { - if (param.flags & 112 /* AccessibilityModifier */) { + if (param.flags & 112) { writeLine(); emitStart(param); emitStart(param.name); @@ -27509,13 +23296,12 @@ var ts; }); } function emitMemberAccessForPropertyName(memberName) { - // TODO: (jfreeman,drosen): comment on why this is emitNodeWithoutSourceMap instead of emit here. - if (memberName.kind === 8 /* StringLiteral */ || memberName.kind === 7 /* NumericLiteral */) { + if (memberName.kind === 8 || memberName.kind === 7) { write("["); emitNodeWithoutSourceMap(memberName); write("]"); } - else if (memberName.kind === 128 /* ComputedPropertyName */) { + else if (memberName.kind === 128) { emitComputedPropertyName(memberName); } else { @@ -27527,7 +23313,7 @@ var ts; var properties = []; for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if (member.kind === 133 /* PropertyDeclaration */ && isStatic === ((member.flags & 128 /* Static */) !== 0) && member.initializer) { + if (member.kind === 133 && isStatic === ((member.flags & 128) !== 0) && member.initializer) { properties.push(member); } } @@ -27548,7 +23334,7 @@ var ts; emit(receiver); } else { - if (property.flags & 128 /* Static */) { + if (property.flags & 128) { emitDeclarationName(node); } else { @@ -27567,11 +23353,11 @@ var ts; } function emitMemberFunctionsForES5AndLower(node) { ts.forEach(node.members, function (member) { - if (member.kind === 179 /* SemicolonClassElement */) { + if (member.kind === 179) { writeLine(); write(";"); } - else if (member.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */) { + else if (member.kind === 135 || node.kind === 134) { if (!member.body) { return emitOnlyPinnedOrTripleSlashComments(member); } @@ -27590,7 +23376,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 137 /* GetAccessor */ || member.kind === 138 /* SetAccessor */) { + else if (member.kind === 137 || member.kind === 138) { var accessors = ts.getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -27640,22 +23426,22 @@ var ts; function emitMemberFunctionsForES6AndHigher(node) { for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if ((member.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */) && !member.body) { + if ((member.kind === 135 || node.kind === 134) && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - else if (member.kind === 135 /* MethodDeclaration */ || - member.kind === 137 /* GetAccessor */ || - member.kind === 138 /* SetAccessor */) { + else if (member.kind === 135 || + member.kind === 137 || + member.kind === 138) { writeLine(); emitLeadingComments(member); emitStart(member); - if (member.flags & 128 /* Static */) { + if (member.flags & 128) { write("static "); } - if (member.kind === 137 /* GetAccessor */) { + if (member.kind === 137) { write("get "); } - else if (member.kind === 138 /* SetAccessor */) { + else if (member.kind === 138) { write("set "); } if (member.asteriskToken) { @@ -27666,7 +23452,7 @@ var ts; emitEnd(member); emitTrailingComments(member); } - else if (member.kind === 179 /* SemicolonClassElement */) { + else if (member.kind === 179) { writeLine(); write(";"); } @@ -27685,31 +23471,24 @@ var ts; tempParameters = saveTempParameters; } function emitConstructorWorker(node, baseTypeElement) { - // Check if we have property assignment inside class declaration. - // If there is property assignment, we need to emit constructor whether users define it or not - // If there is no property assignment, we can omit constructor if users do not define it var hasInstancePropertyWithInitializer = false; - // Emit the constructor overload pinned comments ts.forEach(node.members, function (member) { - if (member.kind === 136 /* Constructor */ && !member.body) { + if (member.kind === 136 && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - // Check if there is any non-static property assignment - if (member.kind === 133 /* PropertyDeclaration */ && member.initializer && (member.flags & 128 /* Static */) === 0) { + if (member.kind === 133 && member.initializer && (member.flags & 128) === 0) { hasInstancePropertyWithInitializer = true; } }); var ctor = ts.getFirstConstructorWithBody(node); - // For target ES6 and above, if there is no user-defined constructor and there is no property assignment - // do not emit constructor in class declaration. - if (languageVersion >= 2 /* ES6 */ && !ctor && !hasInstancePropertyWithInitializer) { + if (languageVersion >= 2 && !ctor && !hasInstancePropertyWithInitializer) { return; } if (ctor) { emitLeadingComments(ctor); } emitStart(ctor || node); - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { write("function "); emitDeclarationName(node); emitSignatureParameters(ctor); @@ -27720,12 +23499,6 @@ var ts; emitSignatureParameters(ctor); } else { - // Based on EcmaScript6 section 14.5.14: Runtime Semantics: ClassDefinitionEvaluation. - // If constructor is empty, then, - // If ClassHeritageopt is present, then - // Let constructor be the result of parsing the String "constructor(... args){ super (...args);}" using the syntactic grammar with the goal symbol MethodDefinition. - // Else, - // Let constructor be the result of parsing the String "constructor( ){ }" using the syntactic grammar with the goal symbol MethodDefinition if (baseTypeElement) { write("(...args)"); } @@ -27757,7 +23530,7 @@ var ts; if (baseTypeElement) { writeLine(); emitStart(baseTypeElement); - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { write("_super.apply(this, arguments);"); } else { @@ -27780,7 +23553,7 @@ var ts; emitLeadingCommentsOfPosition(ctor.body.statements.end); } decreaseIndent(); - emitToken(15 /* CloseBraceToken */, ctor ? ctor.body.statements.end : node.members.end); + emitToken(15, ctor ? ctor.body.statements.end : node.members.end); scopeEmitEnd(); emitEnd(ctor || node); if (ctor) { @@ -27794,7 +23567,7 @@ var ts; return emitClassLikeDeclaration(node); } function emitClassLikeDeclaration(node) { - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { emitClassLikeDeclarationBelowES6(node); } else { @@ -27803,61 +23576,9 @@ var ts; } function emitClassLikeDeclarationForES6AndHigher(node) { var thisNodeIsDecorated = ts.nodeIsDecorated(node); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 202) { if (thisNodeIsDecorated) { - // To preserve the correct runtime semantics when decorators are applied to the class, - // the emit needs to follow one of the following rules: - // - // * For a local class declaration: - // - // @dec class C { - // } - // - // The emit should be: - // - // let C = class { - // }; - // Object.defineProperty(C, "name", { value: "C", configurable: true }); - // C = __decorate([dec], C); - // - // * For an exported class declaration: - // - // @dec export class C { - // } - // - // The emit should be: - // - // export let C = class { - // }; - // Object.defineProperty(C, "name", { value: "C", configurable: true }); - // C = __decorate([dec], C); - // - // * For a default export of a class declaration with a name: - // - // @dec default export class C { - // } - // - // The emit should be: - // - // let C = class { - // } - // Object.defineProperty(C, "name", { value: "C", configurable: true }); - // C = __decorate([dec], C); - // export default C; - // - // * For a default export of a class declaration without a name: - // - // @dec default export class { - // } - // - // The emit should be: - // - // let _default = class { - // } - // _default = __decorate([dec], _default); - // export default _default; - // - if (isES6ExportedDeclaration(node) && !(node.flags & 256 /* Default */)) { + if (isES6ExportedDeclaration(node) && !(node.flags & 256)) { write("export "); } write("let "); @@ -27866,35 +23587,23 @@ var ts; } else if (isES6ExportedDeclaration(node)) { write("export "); - if (node.flags & 256 /* Default */) { + if (node.flags & 256) { write("default "); } } } - // If the class has static properties, and it's a class expression, then we'll need - // to specialize the emit a bit. for a class expression of the form: - // - // class C { static a = 1; static b = 2; ... } - // - // We'll emit: - // - // (_temp = class C { ... }, _temp.a = 1, _temp.b = 2, _temp) - // - // This keeps the expression as an expression, while ensuring that the static parts - // of it have been initialized by the time it is used. var staticProperties = getInitializedProperties(node, true); - var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 175 /* ClassExpression */; + var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 175; var tempVariable; if (isClassExpressionWithStaticProperties) { - tempVariable = createAndRecordTempVariable(0 /* Auto */); + tempVariable = createAndRecordTempVariable(0); write("("); increaseIndent(); emit(tempVariable); write(" = "); } write("class"); - // check if this is an "export default class" as it may not have a name. Do not emit the name if the class is decorated. - if ((node.name || !(node.flags & 256 /* Default */)) && !thisNodeIsDecorated) { + if ((node.name || !(node.flags & 256)) && !thisNodeIsDecorated) { write(" "); emitDeclarationName(node); } @@ -27911,15 +23620,8 @@ var ts; emitMemberFunctionsForES6AndHigher(node); decreaseIndent(); writeLine(); - emitToken(15 /* CloseBraceToken */, node.members.end); + emitToken(15, node.members.end); scopeEmitEnd(); - // For a decorated class, we need to assign its name (if it has one). This is because we emit - // the class as a class expression to avoid the double-binding of the identifier: - // - // let C = class { - // } - // Object.defineProperty(C, "name", { value: "C", configurable: true }); - // if (thisNodeIsDecorated) { write(";"); if (node.name) { @@ -27932,11 +23634,6 @@ var ts; writeLine(); } } - // Emit static property assignment. Because classDeclaration is lexically evaluated, - // it is safe to emit static property assignment after classDeclaration - // From ES6 specification: - // HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using - // a lexical declaration such as a LexicalDeclaration or a ClassDeclaration. if (isClassExpressionWithStaticProperties) { for (var _a = 0; _a < staticProperties.length; _a++) { var property = staticProperties[_a]; @@ -27955,9 +23652,7 @@ var ts; emitPropertyDeclarations(node, staticProperties); emitDecoratorsOfClass(node); } - // If this is an exported class, but not on the top level (i.e. on an internal - // module), export it - if (!isES6ExportedDeclaration(node) && (node.flags & 1 /* Export */)) { + if (!isES6ExportedDeclaration(node) && (node.flags & 1)) { writeLine(); emitStart(node); emitModuleMemberName(node); @@ -27966,8 +23661,7 @@ var ts; emitEnd(node); write(";"); } - else if (isES6ExportedDeclaration(node) && (node.flags & 256 /* Default */) && thisNodeIsDecorated) { - // if this is a top level default export of decorated class, write the export after the declaration. + else if (isES6ExportedDeclaration(node) && (node.flags & 256) && thisNodeIsDecorated) { writeLine(); write("export default "); emitDeclarationName(node); @@ -27975,8 +23669,7 @@ var ts; } } function emitClassLikeDeclarationBelowES6(node) { - if (node.kind === 202 /* ClassDeclaration */) { - // source file level classes in system modules are hoisted so 'var's for them are already defined + if (node.kind === 202) { if (!shouldHoistDeclarationInSystemJsModule(node)) { write("var "); } @@ -28014,7 +23707,7 @@ var ts; writeLine(); emitDecoratorsOfClass(node); writeLine(); - emitToken(15 /* CloseBraceToken */, node.members.end, function () { + emitToken(15, node.members.end, function () { write("return "); emitDeclarationName(node); }); @@ -28026,7 +23719,7 @@ var ts; computedPropertyNamesToGeneratedNames = saveComputedPropertyNamesToGeneratedNames; decreaseIndent(); writeLine(); - emitToken(15 /* CloseBraceToken */, node.members.end); + emitToken(15, node.members.end); scopeEmitEnd(); emitStart(node); write(")("); @@ -28034,46 +23727,35 @@ var ts; emit(baseTypeNode.expression); } write(")"); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 202) { write(";"); } emitEnd(node); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 202) { emitExportMemberAssignment(node); } - if (languageVersion < 2 /* ES6 */ && node.parent === currentSourceFile && node.name) { + if (languageVersion < 2 && node.parent === currentSourceFile && node.name) { emitExportMemberAssignments(node.name); } } function emitClassMemberPrefix(node, member) { emitDeclarationName(node); - if (!(member.flags & 128 /* Static */)) { + if (!(member.flags & 128)) { write(".prototype"); } } function emitDecoratorsOfClass(node) { emitDecoratorsOfMembers(node, 0); - emitDecoratorsOfMembers(node, 128 /* Static */); + emitDecoratorsOfMembers(node, 128); emitDecoratorsOfConstructor(node); } function emitDecoratorsOfConstructor(node) { var decorators = node.decorators; var constructor = ts.getFirstConstructorWithBody(node); var hasDecoratedParameters = constructor && ts.forEach(constructor.parameters, ts.nodeIsDecorated); - // skip decoration of the constructor if neither it nor its parameters are decorated if (!decorators && !hasDecoratedParameters) { return; } - // Emit the call to __decorate. Given the class: - // - // @dec - // class C { - // } - // - // The emit for the class is: - // - // C = __decorate([dec], C); - // writeLine(); emitStart(node); emitDeclarationName(node); @@ -28099,19 +23781,15 @@ var ts; function emitDecoratorsOfMembers(node, staticFlag) { for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - // only emit members in the correct group - if ((member.flags & 128 /* Static */) !== staticFlag) { + if ((member.flags & 128) !== staticFlag) { continue; } - // skip members that cannot be decorated (such as the constructor) if (!ts.nodeCanBeDecorated(member)) { continue; } - // skip a member if it or any of its parameters are not decorated if (!ts.nodeOrChildIsDecorated(member)) { continue; } - // skip an accessor declaration if it is not the first accessor var decorators = void 0; var functionLikeMember = void 0; if (ts.isAccessor(member)) { @@ -28119,56 +23797,21 @@ var ts; if (member !== accessors.firstAccessor) { continue; } - // get the decorators from the first accessor with decorators decorators = accessors.firstAccessor.decorators; if (!decorators && accessors.secondAccessor) { decorators = accessors.secondAccessor.decorators; } - // we only decorate parameters of the set accessor functionLikeMember = accessors.setAccessor; } else { decorators = member.decorators; - // we only decorate the parameters here if this is a method - if (member.kind === 135 /* MethodDeclaration */) { + if (member.kind === 135) { functionLikeMember = member; } } - // Emit the call to __decorate. Given the following: - // - // class C { - // @dec method(@dec2 x) {} - // @dec get accessor() {} - // @dec prop; - // } - // - // The emit for a method is: - // - // Object.defineProperty(C.prototype, "method", - // __decorate([ - // dec, - // __param(0, dec2), - // __metadata("design:type", Function), - // __metadata("design:paramtypes", [Object]), - // __metadata("design:returntype", void 0) - // ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); - // - // The emit for an accessor is: - // - // Object.defineProperty(C.prototype, "accessor", - // __decorate([ - // dec - // ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); - // - // The emit for a property is: - // - // __decorate([ - // dec - // ], C.prototype, "prop"); - // writeLine(); emitStart(member); - if (member.kind !== 133 /* PropertyDeclaration */) { + if (member.kind !== 133) { write("Object.defineProperty("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -28198,7 +23841,7 @@ var ts; write(", "); emitExpressionForPropertyName(member.name); emitEnd(member.name); - if (member.kind !== 133 /* PropertyDeclaration */) { + if (member.kind !== 133) { write(", Object.getOwnPropertyDescriptor("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -28236,43 +23879,32 @@ var ts; return argumentsWritten; } function shouldEmitTypeMetadata(node) { - // This method determines whether to emit the "design:type" metadata based on the node's kind. - // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata - // compiler option is set. switch (node.kind) { - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 133 /* PropertyDeclaration */: + case 135: + case 137: + case 138: + case 133: return true; } return false; } function shouldEmitReturnTypeMetadata(node) { - // This method determines whether to emit the "design:returntype" metadata based on the node's kind. - // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata - // compiler option is set. switch (node.kind) { - case 135 /* MethodDeclaration */: + case 135: return true; } return false; } function shouldEmitParamTypesMetadata(node) { - // This method determines whether to emit the "design:paramtypes" metadata based on the node's kind. - // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata - // compiler option is set. switch (node.kind) { - case 202 /* ClassDeclaration */: - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 202: + case 135: + case 138: return true; } return false; } function emitSerializedTypeMetadata(node, writeComma) { - // This method emits the serialized type metadata for a decorator target. - // The caller should have already tested whether the node has decorators. var argumentsWritten = 0; if (compilerOptions.emitDecoratorMetadata) { if (shouldEmitTypeMetadata(node)) { @@ -28329,7 +23961,7 @@ var ts; case 1: return serializeTypeNameSegment(location, path, index - 1) + "." + path[index]; default: - var temp = createAndRecordTempVariable(0 /* Auto */).text; + var temp = createAndRecordTempVariable(0).text; return "(" + temp + " = " + serializeTypeNameSegment(location, path, index - 1) + ") && " + temp + "." + path[index]; } } @@ -28351,11 +23983,10 @@ var ts; return !isConstEnum || compilerOptions.preserveConstEnums || compilerOptions.separateCompilation; } function emitEnumDeclaration(node) { - // const enums are completely erased during compilation. if (!shouldEmitEnumDeclaration(node)) { return; } - if (!(node.flags & 1 /* Export */) || isES6ExportedDeclaration(node)) { + if (!(node.flags & 1) || isES6ExportedDeclaration(node)) { emitStart(node); if (isES6ExportedDeclaration(node)) { write("export "); @@ -28377,7 +24008,7 @@ var ts; emitLines(node.members); decreaseIndent(); writeLine(); - emitToken(15 /* CloseBraceToken */, node.members.end); + emitToken(15, node.members.end); scopeEmitEnd(); write(")("); emitModuleMemberName(node); @@ -28385,7 +24016,7 @@ var ts; emitModuleMemberName(node); write(" = {}));"); emitEnd(node); - if (!isES6ExportedDeclaration(node) && node.flags & 1 /* Export */) { + if (!isES6ExportedDeclaration(node) && node.flags & 1) { writeLine(); emitStart(node); write("var "); @@ -28395,7 +24026,7 @@ var ts; emitEnd(node); write(";"); } - if (languageVersion < 2 /* ES6 */ && node.parent === currentSourceFile) { + if (languageVersion < 2 && node.parent === currentSourceFile) { emitExportMemberAssignments(node.name); } } @@ -28428,7 +24059,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 206 /* ModuleDeclaration */) { + if (moduleDeclaration.body.kind === 206) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -28437,10 +24068,9 @@ var ts; return ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.separateCompilation); } function isModuleMergedWithES6Class(node) { - return languageVersion === 2 /* ES6 */ && !!(resolver.getNodeCheckFlags(node) & 2048 /* LexicalModuleMergesWithClass */); + return languageVersion === 2 && !!(resolver.getNodeCheckFlags(node) & 2048); } function emitModuleDeclaration(node) { - // Emit only if this module is non-ambient. var shouldEmit = shouldEmitModuleDeclaration(node); if (!shouldEmit) { return emitOnlyPinnedOrTripleSlashComments(node); @@ -28464,7 +24094,7 @@ var ts; write(getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 207 /* ModuleBlock */) { + if (node.body.kind === 207) { var saveTempFlags = tempFlags; var saveTempVariables = tempVariables; tempFlags = 0; @@ -28483,12 +24113,11 @@ var ts; decreaseIndent(); writeLine(); var moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body; - emitToken(15 /* CloseBraceToken */, moduleBlock.statements.end); + emitToken(15, moduleBlock.statements.end); scopeEmitEnd(); } write(")("); - // write moduleDecl = containingModule.m only if it is not exported es6 module member - if ((node.flags & 1 /* Export */) && !isES6ExportedDeclaration(node)) { + if ((node.flags & 1) && !isES6ExportedDeclaration(node)) { emit(node.name); write(" = "); } @@ -28497,8 +24126,8 @@ var ts; emitModuleMemberName(node); write(" = {}));"); emitEnd(node); - if (!isES6ExportedDeclaration(node) && node.name.kind === 65 /* Identifier */ && node.parent === currentSourceFile) { - if (compilerOptions.module === 4 /* System */ && (node.flags & 1 /* Export */)) { + if (!isES6ExportedDeclaration(node) && node.name.kind === 65 && node.parent === currentSourceFile) { + if (compilerOptions.module === 4 && (node.flags & 1)) { writeLine(); write(exportFunctionForFile + "(\""); emitDeclarationName(node); @@ -28510,28 +24139,28 @@ var ts; } } function emitRequire(moduleName) { - if (moduleName.kind === 8 /* StringLiteral */) { + if (moduleName.kind === 8) { write("require("); emitStart(moduleName); emitLiteral(moduleName); emitEnd(moduleName); - emitToken(17 /* CloseParenToken */, moduleName.end); + emitToken(17, moduleName.end); } else { write("require()"); } } function getNamespaceDeclarationNode(node) { - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 209) { return node; } var importClause = node.importClause; - if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 212) { return importClause.namedBindings; } } function isDefaultImport(node) { - return node.kind === 210 /* ImportDeclaration */ && node.importClause && !!node.importClause.name; + return node.kind === 210 && node.importClause && !!node.importClause.name; } function emitExportImportAssignments(node) { if (ts.isAliasSymbolDeclaration(node) && resolver.isValueAliasDeclaration(node)) { @@ -28540,10 +24169,9 @@ var ts; ts.forEachChild(node, emitExportImportAssignments); } function emitImportDeclaration(node) { - if (languageVersion < 2 /* ES6 */) { + if (languageVersion < 2) { return emitExternalImportDeclaration(node); } - // ES6 import if (node.importClause) { var shouldEmitDefaultBindings = resolver.isReferencedAliasDeclaration(node.importClause); var shouldEmitNamedBindings = node.importClause.namedBindings && resolver.isReferencedAliasDeclaration(node.importClause.namedBindings, true); @@ -28559,7 +24187,7 @@ var ts; if (shouldEmitNamedBindings) { emitLeadingComments(node.importClause.namedBindings); emitStart(node.importClause.namedBindings); - if (node.importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (node.importClause.namedBindings.kind === 212) { write("* as "); emit(node.importClause.namedBindings.name); } @@ -28585,26 +24213,19 @@ var ts; } function emitExternalImportDeclaration(node) { if (ts.contains(externalImports, node)) { - var isExportedImport = node.kind === 209 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0; + var isExportedImport = node.kind === 209 && (node.flags & 1) !== 0; var namespaceDeclaration = getNamespaceDeclarationNode(node); - if (compilerOptions.module !== 2 /* AMD */) { + if (compilerOptions.module !== 2) { emitLeadingComments(node); emitStart(node); if (namespaceDeclaration && !isDefaultImport(node)) { - // import x = require("foo") - // import * as x from "foo" if (!isExportedImport) write("var "); emitModuleMemberName(namespaceDeclaration); write(" = "); } else { - // import "foo" - // import x from "foo" - // import { x, y } from "foo" - // import d, * as x from "foo" - // import d, { x, y } from "foo" - var isNakedImport = 210 /* ImportDeclaration */ && !node.importClause; + var isNakedImport = 210 && !node.importClause; if (!isNakedImport) { write("var "); write(getGeneratedNameForNode(node)); @@ -28613,7 +24234,6 @@ var ts; } emitRequire(ts.getExternalModuleName(node)); if (namespaceDeclaration && isDefaultImport(node)) { - // import d, * as x from "foo" write(", "); emitModuleMemberName(namespaceDeclaration); write(" = "); @@ -28632,7 +24252,6 @@ var ts; write(";"); } else if (namespaceDeclaration && isDefaultImport(node)) { - // import d, * as x from "foo" write("var "); emitModuleMemberName(namespaceDeclaration); write(" = "); @@ -28648,9 +24267,6 @@ var ts; emitExternalImportDeclaration(node); return; } - // preserve old compiler's behavior: emit 'var' for import declaration (even if we do not consider them referenced) when - // - current file is not external module - // - import declaration is top level and target is value imported by entity name if (resolver.isReferencedAliasDeclaration(node) || (!ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node))) { emitLeadingComments(node); @@ -28659,7 +24275,7 @@ var ts; write("export "); write("var "); } - else if (!(node.flags & 1 /* Export */)) { + else if (!(node.flags & 1)) { write("var "); } emitModuleMemberName(node); @@ -28672,14 +24288,13 @@ var ts; } } function emitExportDeclaration(node) { - ts.Debug.assert(compilerOptions.module !== 4 /* System */); - if (languageVersion < 2 /* ES6 */) { + ts.Debug.assert(compilerOptions.module !== 4); + if (languageVersion < 2) { if (node.moduleSpecifier && (!node.exportClause || resolver.isValueAliasDeclaration(node))) { emitStart(node); var generatedName = getGeneratedNameForNode(node); if (node.exportClause) { - // export { x, y, ... } from "foo" - if (compilerOptions.module !== 2 /* AMD */) { + if (compilerOptions.module !== 2) { write("var "); write(generatedName); write(" = "); @@ -28704,10 +24319,9 @@ var ts; } } else { - // export * from "foo" writeLine(); write("__export("); - if (compilerOptions.module !== 2 /* AMD */) { + if (compilerOptions.module !== 2) { emitRequire(ts.getExternalModuleName(node)); } else { @@ -28723,7 +24337,6 @@ var ts; emitStart(node); write("export "); if (node.exportClause) { - // export { x, y, ... } write("{ "); emitExportOrImportSpecifierList(node.exportClause.elements, resolver.isValueAliasDeclaration); write(" }"); @@ -28741,7 +24354,7 @@ var ts; } } function emitExportOrImportSpecifierList(specifiers, shouldEmit) { - ts.Debug.assert(languageVersion >= 2 /* ES6 */); + ts.Debug.assert(languageVersion >= 2); var needsComma = false; for (var _a = 0; _a < specifiers.length; _a++) { var specifier = specifiers[_a]; @@ -28762,14 +24375,14 @@ var ts; } function emitExportAssignment(node) { if (!node.isExportEquals && resolver.isValueAliasDeclaration(node)) { - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { writeLine(); emitStart(node); write("export default "); var expression = node.expression; emit(expression); - if (expression.kind !== 201 /* FunctionDeclaration */ && - expression.kind !== 202 /* ClassDeclaration */) { + if (expression.kind !== 201 && + expression.kind !== 202) { write(";"); } emitEnd(node); @@ -28777,14 +24390,14 @@ var ts; else { writeLine(); emitStart(node); - if (compilerOptions.module === 4 /* System */) { + if (compilerOptions.module === 4) { write(exportFunctionForFile + "(\"default\","); emit(node.expression); write(")"); } else { emitContainingModuleName(node); - if (languageVersion === 0 /* ES3 */) { + if (languageVersion === 0) { write("[\"default\"] = "); } else { @@ -28805,36 +24418,28 @@ var ts; for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) { var node = _b[_a]; switch (node.kind) { - case 210 /* ImportDeclaration */: + case 210: if (!node.importClause || resolver.isReferencedAliasDeclaration(node.importClause, true)) { - // import "mod" - // import x from "mod" where x is referenced - // import * as x from "mod" where x is referenced - // import { x, y } from "mod" where at least one import is referenced externalImports.push(node); } break; - case 209 /* ImportEqualsDeclaration */: - if (node.moduleReference.kind === 220 /* ExternalModuleReference */ && resolver.isReferencedAliasDeclaration(node)) { - // import x = require("mod") where x is referenced + case 209: + if (node.moduleReference.kind === 220 && resolver.isReferencedAliasDeclaration(node)) { externalImports.push(node); } break; - case 216 /* ExportDeclaration */: + case 216: if (node.moduleSpecifier) { if (!node.exportClause) { - // export * from "mod" externalImports.push(node); hasExportStars = true; } else if (resolver.isValueAliasDeclaration(node)) { - // export { x, y } from "mod" where at least one export is a value symbol externalImports.push(node); } } else { - // export { x, y } for (var _c = 0, _d = node.exportClause.elements; _c < _d.length; _c++) { var specifier = _d[_c]; var name_20 = (specifier.propertyName || specifier.name).text; @@ -28842,9 +24447,8 @@ var ts; } } break; - case 215 /* ExportAssignment */: + case 215: if (node.isExportEquals && !exportEquals) { - // export = x exportEquals = node; } break; @@ -28874,7 +24478,7 @@ var ts; } function getExternalModuleNameText(importNode) { var moduleName = ts.getExternalModuleName(importNode); - if (moduleName.kind === 8 /* StringLiteral */) { + if (moduleName.kind === 8) { return getLiteralText(moduleName); } return undefined; @@ -28887,9 +24491,8 @@ var ts; var started = false; for (var _a = 0; _a < externalImports.length; _a++) { var importNode = externalImports[_a]; - // do not create variable declaration for exports and imports that lack import clause - var skipNode = importNode.kind === 216 /* ExportDeclaration */ || - (importNode.kind === 210 /* ImportDeclaration */ && !importNode.importClause); + var skipNode = importNode.kind === 216 || + (importNode.kind === 210 && !importNode.importClause); if (skipNode) { continue; } @@ -28907,28 +24510,19 @@ var ts; } } function emitLocalStorageForExportedNamesIfNecessary(exportedDeclarations) { - // when resolving exports local exported entries/indirect exported entries in the module - // should always win over entries with similar names that were added via star exports - // to support this we store names of local/indirect exported entries in a set. - // this set is used to filter names brought by star expors. if (!hasExportStars) { - // local names set is needed only in presence of star exports return undefined; } - // local names set should only be added if we have anything exported if (!exportedDeclarations && ts.isEmpty(exportSpecifiers)) { - // no exported declarations (export var ...) or export specifiers (export {x}) - // check if we have any non star export declarations. var hasExportDeclarationWithExportClause = false; for (var _a = 0; _a < externalImports.length; _a++) { var externalImport = externalImports[_a]; - if (externalImport.kind === 216 /* ExportDeclaration */ && externalImport.exportClause) { + if (externalImport.kind === 216 && externalImport.exportClause) { hasExportDeclarationWithExportClause = true; break; } } if (!hasExportDeclarationWithExportClause) { - // we still need to emit exportStar helper return emitExportStarFunction(undefined); } } @@ -28939,7 +24533,6 @@ var ts; var started = false; if (exportedDeclarations) { for (var i = 0; i < exportedDeclarations.length; ++i) { - // write name of exported declaration, i.e 'export var x...' writeExportedName(exportedDeclarations[i]); } } @@ -28947,24 +24540,21 @@ var ts; for (var n in exportSpecifiers) { for (var _b = 0, _c = exportSpecifiers[n]; _b < _c.length; _b++) { var specifier = _c[_b]; - // write name of export specified, i.e. 'export {x}' writeExportedName(specifier.name); } } } for (var _d = 0; _d < externalImports.length; _d++) { var externalImport = externalImports[_d]; - if (externalImport.kind !== 216 /* ExportDeclaration */) { + if (externalImport.kind !== 216) { continue; } var exportDecl = externalImport; if (!exportDecl.exportClause) { - // export * from ... continue; } for (var _e = 0, _f = exportDecl.exportClause.elements; _e < _f.length; _e++) { var element = _f[_e]; - // write name of indirectly exported entry, i.e. 'export {x} from ...' writeExportedName(element.name || element.propertyName); } } @@ -28975,7 +24565,6 @@ var ts; function emitExportStarFunction(localNames) { var exportStarFunction = makeUniqueName("exportStar"); writeLine(); - // define an export star helper function write("function " + exportStarFunction + "(m) {"); increaseIndent(); writeLine(); @@ -28996,9 +24585,7 @@ var ts; return exportStarFunction; } function writeExportedName(node) { - // do not record default exports - // they are local to module and never overwritten (explicitly skipped) by star export - if (node.kind !== 65 /* Identifier */ && node.flags & 256 /* Default */) { + if (node.kind !== 65 && node.flags & 256) { return; } if (started) { @@ -29009,7 +24596,7 @@ var ts; } writeLine(); write("'"); - if (node.kind === 65 /* Identifier */) { + if (node.kind === 65) { emitNodeWithoutSourceMap(node); } else { @@ -29019,15 +24606,6 @@ var ts; } } function processTopLevelVariableAndFunctionDeclarations(node) { - // per ES6 spec: - // 15.2.1.16.4 ModuleDeclarationInstantiation() Concrete Method - // - var declarations are initialized to undefined - 14.a.ii - // - function/generator declarations are instantiated - 16.a.iv - // this means that after module is instantiated but before its evaluation - // exported functions are already accessible at import sites - // in theory we should hoist only exported functions and its dependencies - // in practice to simplify things we'll hoist all source level functions and variable declaration - // including variables declarations for module and class declarations var hoistedVars; var hoistedFunctionDeclarations; var exportedDeclarations; @@ -29040,14 +24618,14 @@ var ts; if (i !== 0) { write(", "); } - if (local.kind === 202 /* ClassDeclaration */ || local.kind === 206 /* ModuleDeclaration */) { + if (local.kind === 202 || local.kind === 206) { emitDeclarationName(local); } else { emit(local); } - var flags = ts.getCombinedNodeFlags(local.kind === 65 /* Identifier */ ? local.parent : local); - if (flags & 1 /* Export */) { + var flags = ts.getCombinedNodeFlags(local.kind === 65 ? local.parent : local); + if (flags & 1) { if (!exportedDeclarations) { exportedDeclarations = []; } @@ -29061,7 +24639,7 @@ var ts; var f = hoistedFunctionDeclarations[_a]; writeLine(); emit(f); - if (f.flags & 1 /* Export */) { + if (f.flags & 1) { if (!exportedDeclarations) { exportedDeclarations = []; } @@ -29071,32 +24649,31 @@ var ts; } return exportedDeclarations; function visit(node) { - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 201) { if (!hoistedFunctionDeclarations) { hoistedFunctionDeclarations = []; } hoistedFunctionDeclarations.push(node); return; } - if (node.kind === 202 /* ClassDeclaration */) { - // TODO: rename block scoped classes + if (node.kind === 202) { if (!hoistedVars) { hoistedVars = []; } hoistedVars.push(node); return; } - if (node.kind === 206 /* ModuleDeclaration */ && shouldEmitModuleDeclaration(node)) { + if (node.kind === 206 && shouldEmitModuleDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; } hoistedVars.push(node); return; } - if (node.kind === 199 /* VariableDeclaration */ || node.kind === 153 /* BindingElement */) { + if (node.kind === 199 || node.kind === 153) { if (shouldHoistVariable(node, false)) { var name_21 = node.name; - if (name_21.kind === 65 /* Identifier */) { + if (name_21.kind === 65) { if (!hoistedVars) { hoistedVars = []; } @@ -29121,54 +24698,13 @@ var ts; if (checkIfSourceFileLevelDecl && !shouldHoistDeclarationInSystemJsModule(node)) { return false; } - // hoist variable if - // - it is not block scoped - // - it is top level block scoped - // if block scoped variables are nested in some another block then - // no other functions can use them except ones that are defined at least in the same block - return (ts.getCombinedNodeFlags(node) & 12288 /* BlockScoped */) === 0 || - ts.getEnclosingBlockScopeContainer(node).kind === 228 /* SourceFile */; + return (ts.getCombinedNodeFlags(node) & 12288) === 0 || + ts.getEnclosingBlockScopeContainer(node).kind === 228; } function isCurrentFileSystemExternalModule() { - return compilerOptions.module === 4 /* System */ && ts.isExternalModule(currentSourceFile); + return compilerOptions.module === 4 && ts.isExternalModule(currentSourceFile); } function emitSystemModuleBody(node, startIndex) { - // shape of the body in system modules: - // function (exports) { - // - // - // - // return { - // setters: [ - // - // ], - // execute: function() { - // - // } - // } - // - // } - // I.e: - // import {x} from 'file1' - // var y = 1; - // export function foo() { return y + x(); } - // console.log(y); - // will be transformed to - // function(exports) { - // var file1; // local alias - // var y; - // function foo() { return y + file1.x(); } - // exports("foo", foo); - // return { - // setters: [ - // function(v) { file1 = v } - // ], - // execute(): function() { - // y = 1; - // console.log(y); - // } - // }; - // } emitVariableDeclarationsForImports(); writeLine(); var exportedDeclarations = processTopLevelVariableAndFunctionDeclarations(node); @@ -29183,7 +24719,7 @@ var ts; emitTempDeclarations(true); decreaseIndent(); writeLine(); - write("}"); // return + write("}"); } function emitSetters(exportStarFunction) { write("setters:["); @@ -29198,46 +24734,31 @@ var ts; var parameterName = "_" + importVariableName; write("function (" + parameterName + ") {"); switch (importNode.kind) { - case 210 /* ImportDeclaration */: + case 210: if (!importNode.importClause) { - // 'import "..."' case - // module is imported only for side-effects, setter body will be empty break; } - // fall-through - case 209 /* ImportEqualsDeclaration */: + case 209: ts.Debug.assert(importVariableName !== ""); increaseIndent(); writeLine(); - // save import into the local write(importVariableName + " = " + parameterName + ";"); writeLine(); - var defaultName = importNode.kind === 210 /* ImportDeclaration */ + var defaultName = importNode.kind === 210 ? importNode.importClause.name : importNode.name; if (defaultName) { - // emit re-export for imported default name - // import n1 from 'foo1' - // import n2 = require('foo2') - // export {n1} - // export {n2} emitExportMemberAssignments(defaultName); writeLine(); } - if (importNode.kind === 210 /* ImportDeclaration */ && + if (importNode.kind === 210 && importNode.importClause.namedBindings) { var namedBindings = importNode.importClause.namedBindings; - if (namedBindings.kind === 212 /* NamespaceImport */) { - // emit re-export for namespace - // import * as n from 'foo' - // export {n} + if (namedBindings.kind === 212) { emitExportMemberAssignments(namedBindings.name); writeLine(); } else { - // emit re-exports for named imports - // import {a, b} from 'foo' - // export {a, b as c} for (var _a = 0, _b = namedBindings.elements; _a < _b.length; _a++) { var element = _b[_a]; emitExportMemberAssignments(element.name || element.propertyName); @@ -29247,14 +24768,10 @@ var ts; } decreaseIndent(); break; - case 216 /* ExportDeclaration */: + case 216: ts.Debug.assert(importVariableName !== ""); increaseIndent(); if (importNode.exportClause) { - // export {a, b as c} from 'foo' - // emit as: - // exports('a', _foo["a"]) - // exports('c', _foo["b"]) for (var _c = 0, _d = importNode.exportClause.elements; _c < _d.length; _c++) { var e = _d[_c]; writeLine(); @@ -29267,9 +24784,6 @@ var ts; } else { writeLine(); - // export * from 'foo' - // emit as: - // exportStar(_foo); write(exportStarFunction + "(" + parameterName + ");"); } writeLine(); @@ -29287,13 +24801,11 @@ var ts; writeLine(); for (var i = startIndex; i < node.statements.length; ++i) { var statement = node.statements[i]; - // - imports/exports are not emitted for system modules - // - function declarations are not emitted because they were already hoisted switch (statement.kind) { - case 216 /* ExportDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 201 /* FunctionDeclaration */: + case 216: + case 210: + case 209: + case 201: continue; } writeLine(); @@ -29301,20 +24813,11 @@ var ts; } decreaseIndent(); writeLine(); - write("}"); // execute + write("}"); } function emitSystemModule(node, startIndex) { collectExternalModuleInfo(node); - // System modules has the following shape - // System.register(['dep-1', ... 'dep-n'], function(exports) {/* module body function */}) - // 'exports' here is a function 'exports(name: string, value: T): T' that is used to publish exported values. - // 'exports' returns its 'value' argument so in most cases expressions - // that mutate exported values can be rewritten as: - // expr -> exports('name', expr). - // The only exception in this rule is postfix unary operators, - // see comment to 'emitPostfixUnaryExpression' for more details ts.Debug.assert(!exportFunctionForFile); - // make sure that name of 'exports' function does not conflict with existing identifiers exportFunctionForFile = makeUniqueName("exports"); write("System.register(["); for (var i = 0; i < externalImports.length; ++i) { @@ -29345,14 +24848,9 @@ var ts; // To ensure this is true in cases of modules with no aliases, e.g.: // `import "module"` or `` // we need to add modules without alias names to the end of the dependencies list - var aliasedModuleNames = []; // names of modules with corresponding parameter in the - // factory function. - var unaliasedModuleNames = []; // names of modules with no corresponding parameters in - // factory function. - var importAliasNames = []; // names of the parameters in the factory function; these - // parameters need to match the indexes of the corresponding - // module names in aliasedModuleNames. - // Fill in amd-dependency tags + var aliasedModuleNames = []; + var unaliasedModuleNames = []; + var importAliasNames = []; for (var _a = 0, _b = node.amdDependencies; _a < _b.length; _a++) { var amdDependency = _b[_a]; if (amdDependency.name) { @@ -29365,9 +24863,7 @@ var ts; } for (var _c = 0; _c < externalImports.length; _c++) { var importNode = externalImports[_c]; - // Find the name of the external module var externalModuleName = getExternalModuleNameText(importNode); - // Find the name of the module alias, if there is one var importAliasName = getLocalNameForExternalImport(importNode); if (includeNonAmdDependencies && importAliasName) { aliasedModuleNames.push(externalModuleName); @@ -29421,7 +24917,6 @@ var ts; } function emitUMDModule(node, startIndex) { collectExternalModuleInfo(node); - // Module is detected first to support Browserify users that load into a browser with an AMD loader writeLines("(function (deps, factory) {\n if (typeof module === 'object' && typeof module.exports === 'object') {\n var v = factory(require, exports); if (v !== undefined) module.exports = v;\n }\n else if (typeof define === 'function' && define.amd) {\n define(deps, factory);\n }\n})("); emitAMDDependencies(node, false); write(") {"); @@ -29443,8 +24938,6 @@ var ts; emitCaptureThisForNodeIfNecessary(node); emitLinesStartingAt(node.statements, startIndex); emitTempDeclarations(true); - // Emit exportDefault if it exists will happen as part - // or normal statement emit. } function emitExportEquals(emitAsReturn) { if (exportEquals && resolver.isValueAliasDeclaration(exportEquals)) { @@ -29465,7 +24958,6 @@ var ts; emit(statements[i]); } else { - // return index of the first non prologue directive return i; } } @@ -29482,42 +24974,37 @@ var ts; } } function emitSourceFileNode(node) { - // Start new file on new line writeLine(); emitDetachedComments(node); - // emit prologue directives prior to __extends var startIndex = emitDirectivePrologues(node.statements, false); - // Only emit helpers if the user did not say otherwise. if (!compilerOptions.noEmitHelpers) { - // Only Emit __extends function when target ES5. - // For target ES6 and above, we can emit classDeclaration as is. - if ((languageVersion < 2 /* ES6 */) && (!extendsEmitted && resolver.getNodeCheckFlags(node) & 8 /* EmitExtends */)) { + if ((languageVersion < 2) && (!extendsEmitted && resolver.getNodeCheckFlags(node) & 8)) { writeLines(extendsHelper); extendsEmitted = true; } - if (!decorateEmitted && resolver.getNodeCheckFlags(node) & 512 /* EmitDecorate */) { + if (!decorateEmitted && resolver.getNodeCheckFlags(node) & 512) { writeLines(decorateHelper); if (compilerOptions.emitDecoratorMetadata) { writeLines(metadataHelper); } decorateEmitted = true; } - if (!paramEmitted && resolver.getNodeCheckFlags(node) & 1024 /* EmitParam */) { + if (!paramEmitted && resolver.getNodeCheckFlags(node) & 1024) { writeLines(paramHelper); paramEmitted = true; } } if (ts.isExternalModule(node) || compilerOptions.separateCompilation) { - if (languageVersion >= 2 /* ES6 */) { + if (languageVersion >= 2) { emitES6Module(node, startIndex); } - else if (compilerOptions.module === 2 /* AMD */) { + else if (compilerOptions.module === 2) { emitAMDModule(node, startIndex); } - else if (compilerOptions.module === 4 /* System */) { + else if (compilerOptions.module === 4) { emitSystemModule(node, startIndex); } - else if (compilerOptions.module === 3 /* UMD */) { + else if (compilerOptions.module === 3) { emitUMDModule(node, startIndex); } else { @@ -29539,7 +25026,7 @@ var ts; if (!node) { return; } - if (node.flags & 2 /* Ambient */) { + if (node.flags & 2) { return emitOnlyPinnedOrTripleSlashComments(node); } var emitComments = shouldEmitLeadingAndTrailingComments(node); @@ -29553,204 +25040,191 @@ var ts; } function shouldEmitLeadingAndTrailingComments(node) { switch (node.kind) { - // All of these entities are emitted in a specialized fashion. As such, we allow - // the specialized methods for each to handle the comments on the nodes. - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 215 /* ExportAssignment */: + case 203: + case 201: + case 210: + case 209: + case 204: + case 215: return false; - case 206 /* ModuleDeclaration */: - // Only emit the leading/trailing comments for a module if we're actually - // emitting the module as well. + case 206: return shouldEmitModuleDeclaration(node); - case 205 /* EnumDeclaration */: - // Only emit the leading/trailing comments for an enum if we're actually - // emitting the module as well. + case 205: return shouldEmitEnumDeclaration(node); } - // If this is the expression body of an arrow function that we're down-leveling, - // then we don't want to emit comments when we emit the body. It will have already - // been taken care of when we emitted the 'return' statement for the function - // expression body. - if (node.kind !== 180 /* Block */ && + if (node.kind !== 180 && node.parent && - node.parent.kind === 164 /* ArrowFunction */ && + node.parent.kind === 164 && node.parent.body === node && - compilerOptions.target <= 1 /* ES5 */) { + compilerOptions.target <= 1) { return false; } - // Emit comments for everything else. return true; } function emitJavaScriptWorker(node, allowGeneratedIdentifiers) { if (allowGeneratedIdentifiers === void 0) { allowGeneratedIdentifiers = true; } - // Check if the node can be emitted regardless of the ScriptTarget switch (node.kind) { - case 65 /* Identifier */: + case 65: return emitIdentifier(node, allowGeneratedIdentifiers); - case 130 /* Parameter */: + case 130: return emitParameter(node); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: return emitMethod(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 137: + case 138: return emitAccessor(node); - case 93 /* ThisKeyword */: + case 93: return emitThis(node); - case 91 /* SuperKeyword */: + case 91: return emitSuper(node); - case 89 /* NullKeyword */: + case 89: return write("null"); - case 95 /* TrueKeyword */: + case 95: return write("true"); - case 80 /* FalseKeyword */: + case 80: return write("false"); - case 7 /* NumericLiteral */: - case 8 /* StringLiteral */: - case 9 /* RegularExpressionLiteral */: - case 10 /* NoSubstitutionTemplateLiteral */: - case 11 /* TemplateHead */: - case 12 /* TemplateMiddle */: - case 13 /* TemplateTail */: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: return emitLiteral(node); - case 172 /* TemplateExpression */: + case 172: return emitTemplateExpression(node); - case 178 /* TemplateSpan */: + case 178: return emitTemplateSpan(node); - case 127 /* QualifiedName */: + case 127: return emitQualifiedName(node); - case 151 /* ObjectBindingPattern */: + case 151: return emitObjectBindingPattern(node); - case 152 /* ArrayBindingPattern */: + case 152: return emitArrayBindingPattern(node); - case 153 /* BindingElement */: + case 153: return emitBindingElement(node); - case 154 /* ArrayLiteralExpression */: + case 154: return emitArrayLiteral(node); - case 155 /* ObjectLiteralExpression */: + case 155: return emitObjectLiteral(node); - case 225 /* PropertyAssignment */: + case 225: return emitPropertyAssignment(node); - case 226 /* ShorthandPropertyAssignment */: + case 226: return emitShorthandPropertyAssignment(node); - case 128 /* ComputedPropertyName */: + case 128: return emitComputedPropertyName(node); - case 156 /* PropertyAccessExpression */: + case 156: return emitPropertyAccess(node); - case 157 /* ElementAccessExpression */: + case 157: return emitIndexedAccess(node); - case 158 /* CallExpression */: + case 158: return emitCallExpression(node); - case 159 /* NewExpression */: + case 159: return emitNewExpression(node); - case 160 /* TaggedTemplateExpression */: + case 160: return emitTaggedTemplateExpression(node); - case 161 /* TypeAssertionExpression */: + case 161: return emit(node.expression); - case 162 /* ParenthesizedExpression */: + case 162: return emitParenExpression(node); - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 201: + case 163: + case 164: return emitFunctionDeclaration(node); - case 165 /* DeleteExpression */: + case 165: return emitDeleteExpression(node); - case 166 /* TypeOfExpression */: + case 166: return emitTypeOfExpression(node); - case 167 /* VoidExpression */: + case 167: return emitVoidExpression(node); - case 168 /* PrefixUnaryExpression */: + case 168: return emitPrefixUnaryExpression(node); - case 169 /* PostfixUnaryExpression */: + case 169: return emitPostfixUnaryExpression(node); - case 170 /* BinaryExpression */: + case 170: return emitBinaryExpression(node); - case 171 /* ConditionalExpression */: + case 171: return emitConditionalExpression(node); - case 174 /* SpreadElementExpression */: + case 174: return emitSpreadElementExpression(node); - case 173 /* YieldExpression */: + case 173: return emitYieldExpression(node); - case 176 /* OmittedExpression */: + case 176: return; - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 180: + case 207: return emitBlock(node); - case 181 /* VariableStatement */: + case 181: return emitVariableStatement(node); - case 182 /* EmptyStatement */: + case 182: return write(";"); - case 183 /* ExpressionStatement */: + case 183: return emitExpressionStatement(node); - case 184 /* IfStatement */: + case 184: return emitIfStatement(node); - case 185 /* DoStatement */: + case 185: return emitDoStatement(node); - case 186 /* WhileStatement */: + case 186: return emitWhileStatement(node); - case 187 /* ForStatement */: + case 187: return emitForStatement(node); - case 189 /* ForOfStatement */: - case 188 /* ForInStatement */: + case 189: + case 188: return emitForInOrForOfStatement(node); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 190: + case 191: return emitBreakOrContinueStatement(node); - case 192 /* ReturnStatement */: + case 192: return emitReturnStatement(node); - case 193 /* WithStatement */: + case 193: return emitWithStatement(node); - case 194 /* SwitchStatement */: + case 194: return emitSwitchStatement(node); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 221: + case 222: return emitCaseOrDefaultClause(node); - case 195 /* LabeledStatement */: + case 195: return emitLabelledStatement(node); - case 196 /* ThrowStatement */: + case 196: return emitThrowStatement(node); - case 197 /* TryStatement */: + case 197: return emitTryStatement(node); - case 224 /* CatchClause */: + case 224: return emitCatchClause(node); - case 198 /* DebuggerStatement */: + case 198: return emitDebuggerStatement(node); - case 199 /* VariableDeclaration */: + case 199: return emitVariableDeclaration(node); - case 175 /* ClassExpression */: + case 175: return emitClassExpression(node); - case 202 /* ClassDeclaration */: + case 202: return emitClassDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 203: return emitInterfaceDeclaration(node); - case 205 /* EnumDeclaration */: + case 205: return emitEnumDeclaration(node); - case 227 /* EnumMember */: + case 227: return emitEnumMember(node); - case 206 /* ModuleDeclaration */: + case 206: return emitModuleDeclaration(node); - case 210 /* ImportDeclaration */: + case 210: return emitImportDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 209: return emitImportEqualsDeclaration(node); - case 216 /* ExportDeclaration */: + case 216: return emitExportDeclaration(node); - case 215 /* ExportAssignment */: + case 215: return emitExportAssignment(node); - case 228 /* SourceFile */: + case 228: return emitSourceFileNode(node); } } function hasDetachedComments(pos) { - return detachedCommentsInfo !== undefined && detachedCommentsInfo[detachedCommentsInfo.length - 1].nodePos === pos; + return detachedCommentsInfo !== undefined && ts.lastOrUndefined(detachedCommentsInfo).nodePos === pos; } function getLeadingCommentsWithoutDetachedComments() { - // get the leading comments from detachedPos - var leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, detachedCommentsInfo[detachedCommentsInfo.length - 1].detachedCommentEndPos); + var leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, ts.lastOrUndefined(detachedCommentsInfo).detachedCommentEndPos); if (detachedCommentsInfo.length - 1) { detachedCommentsInfo.pop(); } @@ -29760,8 +25234,6 @@ var ts; return leadingComments; } function filterComments(ranges, onlyPinnedOrTripleSlashComments) { - // If we're removing comments, then we want to strip out all but the pinned or - // triple slash comments. if (ranges && onlyPinnedOrTripleSlashComments) { ranges = ts.filter(ranges, isPinnedOrTripleSlashComment); if (ranges.length === 0) { @@ -29771,24 +25243,20 @@ var ts; return ranges; } function getLeadingCommentsToEmit(node) { - // Emit the leading comments only if the parent's pos doesn't match because parent should take care of emitting these comments if (node.parent) { - if (node.parent.kind === 228 /* SourceFile */ || node.pos !== node.parent.pos) { + if (node.parent.kind === 228 || node.pos !== node.parent.pos) { if (hasDetachedComments(node.pos)) { - // get comments without detached comments return getLeadingCommentsWithoutDetachedComments(); } else { - // get the leading comments from the node return ts.getLeadingCommentRangesOfNode(node, currentSourceFile); } } } } function getTrailingCommentsToEmit(node) { - // Emit the trailing comments only if the parent's pos doesn't match because parent should take care of emitting these comments if (node.parent) { - if (node.parent.kind === 228 /* SourceFile */ || node.end !== node.parent.end) { + if (node.parent.kind === 228 || node.end !== node.parent.end) { return ts.getTrailingCommentRanges(currentSourceFile.text, node.end); } } @@ -29800,32 +25268,24 @@ var ts; return emitLeadingCommentsWorker(node, compilerOptions.removeComments); } function emitLeadingCommentsWorker(node, onlyPinnedOrTripleSlashComments) { - // If the caller only wants pinned or triple slash comments, then always filter - // down to that set. Otherwise, filter based on the current compiler options. var leadingComments = filterComments(getLeadingCommentsToEmit(node), onlyPinnedOrTripleSlashComments); ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments); - // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space ts.emitComments(currentSourceFile, writer, leadingComments, true, newLine, writeComment); } function emitTrailingComments(node) { - // Emit the trailing comments only if the parent's end doesn't match var trailingComments = filterComments(getTrailingCommentsToEmit(node), compilerOptions.removeComments); - // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/ ts.emitComments(currentSourceFile, writer, trailingComments, false, newLine, writeComment); } function emitLeadingCommentsOfPosition(pos) { var leadingComments; if (hasDetachedComments(pos)) { - // get comments without detached comments leadingComments = getLeadingCommentsWithoutDetachedComments(); } else { - // get the leading comments from the node leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, pos); } leadingComments = filterComments(leadingComments, compilerOptions.removeComments); ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, { pos: pos, end: pos }, leadingComments); - // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space ts.emitComments(currentSourceFile, writer, leadingComments, true, newLine, writeComment); } function emitDetachedComments(node) { @@ -29838,9 +25298,6 @@ var ts; var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, lastComment.end); var commentLine = ts.getLineOfLocalPosition(currentSourceFile, comment.pos); if (commentLine >= lastCommentLine + 2) { - // There was a blank line between the last comment and this comment. This - // comment is not part of the copyright comments. Return what we have so - // far. return detachedComments; } } @@ -29848,16 +25305,12 @@ var ts; lastComment = comment; }); if (detachedComments.length) { - // All comments look like they could have been part of the copyright header. Make - // sure there is at least one blank line between it and the node. If not, it's not - // a copyright header. - var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, detachedComments[detachedComments.length - 1].end); + var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end); var nodeLine = ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos)); if (nodeLine >= lastCommentLine + 2) { - // Valid detachedComments ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments); ts.emitComments(currentSourceFile, writer, detachedComments, true, newLine, writeComment); - var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: detachedComments[detachedComments.length - 1].end }; + var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end }; if (detachedCommentsInfo) { detachedCommentsInfo.push(currentDetachedCommentInfo); } @@ -29869,12 +25322,12 @@ var ts; } } function isPinnedOrTripleSlashComment(comment) { - if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */) { - return currentSourceFile.text.charCodeAt(comment.pos + 2) === 33 /* exclamation */; + if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42) { + return currentSourceFile.text.charCodeAt(comment.pos + 2) === 33; } - else if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 47 /* slash */ && + else if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 47 && comment.pos + 2 < comment.end && - currentSourceFile.text.charCodeAt(comment.pos + 2) === 47 /* slash */ && + currentSourceFile.text.charCodeAt(comment.pos + 2) === 47 && currentSourceFile.text.substring(comment.pos, comment.end).match(ts.fullTripleSlashReferencePathRegEx)) { return true; } @@ -29893,12 +25346,13 @@ var ts; /// var ts; (function (ts) { - /* @internal */ ts.programTime = 0; - /* @internal */ ts.emitTime = 0; - /* @internal */ ts.ioReadTime = 0; - /* @internal */ ts.ioWriteTime = 0; - /** The version of the TypeScript compiler release */ + ts.programTime = 0; + ts.emitTime = 0; + ts.ioReadTime = 0; + ts.ioWriteTime = 0; ts.version = "1.5.0"; + var carriageReturnLineFeed = "\r\n"; + var lineFeed = "\n"; function findConfigFile(searchPath) { var fileName = "tsconfig.json"; while (true) { @@ -29919,11 +25373,8 @@ var ts; var currentDirectory; var existingDirectories = {}; function getCanonicalFileName(fileName) { - // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form. - // otherwise use toLowerCase as a canonical form. return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(); } - // returned by CScript sys environment var unsupportedFileEncodingErrorCode = -2147024809; function getSourceFile(fileName, languageVersion, onError) { var text; @@ -29972,6 +25423,9 @@ var ts; } } } + var newLine = options.newLine === 0 ? carriageReturnLineFeed : + options.newLine === 1 ? lineFeed : + ts.sys.newLine; return { getSourceFile: getSourceFile, getDefaultLibFileName: function (options) { return ts.combinePaths(ts.getDirectoryPath(ts.normalizePath(ts.sys.getExecutingFilePath())), ts.getDefaultLibFileName(options)); }, @@ -29979,7 +25433,7 @@ var ts; getCurrentDirectory: function () { return currentDirectory || (currentDirectory = ts.sys.getCurrentDirectory()); }, useCaseSensitiveFileNames: function () { return ts.sys.useCaseSensitiveFileNames; }, getCanonicalFileName: getCanonicalFileName, - getNewLine: function () { return ts.sys.newLine; } + getNewLine: function () { return newLine; } }; } ts.createCompilerHost = createCompilerHost; @@ -30069,14 +25523,9 @@ var ts; return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, false)); } function emit(sourceFile, writeFileCallback) { - // If the noEmitOnError flag is set, then check if we have any errors so far. If so, - // immediately bail out. if (options.noEmitOnError && getPreEmitDiagnostics(this).length > 0) { return { diagnostics: [], sourceMaps: undefined, emitSkipped: true }; } - // Create the emit resolver outside of the "emitTime" tracking code below. That way - // any cost associated with it (like type checking) are appropriate associated with - // the type-checking counter. var emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile); var start = new Date().getTime(); var emitResult = ts.emitFiles(emitResolver, getEmitHost(writeFileCallback), sourceFile); @@ -30120,7 +25569,6 @@ var ts; function getDeclarationDiagnosticsForFile(sourceFile) { if (!ts.isDeclarationFile(sourceFile)) { var resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile); - // Don't actually write any files since we're just getting diagnostics. var writeFile = function () { }; return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile); } @@ -30175,11 +25623,9 @@ var ts; } } } - // Get source file from normalized fileName function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(fileName); if (ts.hasProperty(filesByName, canonicalName)) { - // We've already looked for this file, use cached result return getSourceFileFromCache(fileName, canonicalName, false); } else { @@ -30188,7 +25634,6 @@ var ts; if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } - // We haven't looked for this file, do so now and cache result var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); @@ -30199,7 +25644,6 @@ var ts; }); if (file) { seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; - // Set the source file for normalized absolute path filesByName[canonicalAbsolutePath] = file; if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); @@ -30234,9 +25678,9 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */ || node.kind === 216 /* ExportDeclaration */) { + if (node.kind === 210 || node.kind === 209 || node.kind === 216) { var moduleNameExpr = ts.getExternalModuleName(node); - if (moduleNameExpr && moduleNameExpr.kind === 8 /* StringLiteral */) { + if (moduleNameExpr && moduleNameExpr.kind === 8) { var moduleNameText = moduleNameExpr.text; if (moduleNameText) { var searchPath = basePath; @@ -30254,21 +25698,13 @@ var ts; } } } - else if (node.kind === 206 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */ && (node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) { - // TypeScript 1.0 spec (April 2014): 12.1.6 - // An AmbientExternalModuleDeclaration declares an external module. - // This type of declaration is permitted only in the global module. - // The StringLiteral must specify a top - level external module name. - // Relative external module names are not permitted + else if (node.kind === 206 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { ts.forEachChild(node.body, function (node) { if (ts.isExternalModuleImportEqualsDeclaration(node) && - ts.getExternalModuleImportEqualsDeclarationExpression(node).kind === 8 /* StringLiteral */) { + ts.getExternalModuleImportEqualsDeclarationExpression(node).kind === 8) { var nameLiteral = ts.getExternalModuleImportEqualsDeclarationExpression(node); var moduleName = nameLiteral.text; if (moduleName) { - // TypeScript 1.0 spec (April 2014): 12.1.6 - // An ExternalImportDeclaration in anAmbientExternalModuleDeclaration may reference other external modules - // only through top - level external module names. Relative external module names are not permitted. var searchName = ts.normalizePath(ts.combinePaths(basePath, moduleName)); var tsFile = findModuleSourceFile(searchName + ".ts", nameLiteral); if (!tsFile) { @@ -30287,14 +25723,12 @@ var ts; var commonPathComponents; var currentDirectory = host.getCurrentDirectory(); ts.forEach(files, function (sourceFile) { - // Each file contributes into common source file path if (ts.isDeclarationFile(sourceFile)) { return; } var sourcePathComponents = ts.getNormalizedPathComponents(sourceFile.fileName, currentDirectory); - sourcePathComponents.pop(); // The base file name is not part of the common directory path + sourcePathComponents.pop(); if (!commonPathComponents) { - // first file commonPathComponents = sourcePathComponents; return; } @@ -30304,12 +25738,10 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files)); return; } - // New common path found that is 0 -> i-1 commonPathComponents.length = i; break; } } - // If the sourcePathComponents was shorter than the commonPathComponents, truncate to the sourcePathComponents if (sourcePathComponents.length < commonPathComponents.length) { commonPathComponents.length = sourcePathComponents.length; } @@ -30366,7 +25798,6 @@ var ts; } } if (!options.sourceMap && (options.mapRoot || options.sourceRoot)) { - // Error to specify --mapRoot or --sourceRoot without mapSourceFiles if (options.mapRoot) { diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option)); } @@ -30375,10 +25806,10 @@ var ts; } return; } - var languageVersion = options.target || 0 /* ES3 */; + var languageVersion = options.target || 0; var firstExternalModuleSourceFile = ts.forEach(files, function (f) { return ts.isExternalModule(f) ? f : undefined; }); if (options.separateCompilation) { - if (!options.module && languageVersion < 2 /* ES6 */) { + if (!options.module && languageVersion < 2) { diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_separateCompilation_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher)); } var firstNonExternalModuleSourceFile = ts.forEach(files, function (f) { return !ts.isExternalModule(f) && !ts.isDeclarationFile(f) ? f : undefined; }); @@ -30387,33 +25818,24 @@ var ts; diagnostics.add(ts.createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_compile_namespaces_when_the_separateCompilation_flag_is_provided)); } } - else if (firstExternalModuleSourceFile && languageVersion < 2 /* ES6 */ && !options.module) { - // We cannot use createDiagnosticFromNode because nodes do not have parents yet + else if (firstExternalModuleSourceFile && languageVersion < 2 && !options.module) { var span = ts.getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator); diagnostics.add(ts.createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_compile_modules_unless_the_module_flag_is_provided)); } - // Cannot specify module gen target when in es6 or above - if (options.module && languageVersion >= 2 /* ES6 */) { + if (options.module && languageVersion >= 2) { diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_compile_modules_into_commonjs_amd_system_or_umd_when_targeting_ES6_or_higher)); } - // there has to be common source directory if user specified --outdir || --sourceRoot - // if user specified --mapRoot, there needs to be common source directory if there would be multiple files being emitted if (options.outDir || options.sourceRoot || (options.mapRoot && (!options.out || firstExternalModuleSourceFile !== undefined))) { if (options.rootDir && checkSourceFilesBelongToPath(files, options.rootDir)) { - // If a rootDir is specified and is valid use it as the commonSourceDirectory commonSourceDirectory = ts.getNormalizedAbsolutePath(options.rootDir, host.getCurrentDirectory()); } else { - // Compute the commonSourceDirectory from the input files commonSourceDirectory = computeCommonSourceDirectory(files); } if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== ts.directorySeparator) { - // Make sure directory path ends with directory separator so this string can directly - // used to replace with "" to get the relative path of the source file and the relative path doesn't - // start with / making it rooted path commonSourceDirectory += ts.directorySeparator; } } @@ -30432,38 +25854,25 @@ var ts; // Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0. // See LICENSE.txt in the project root for complete license information. /// -/* @internal */ var ts; (function (ts) { var BreakpointResolver; (function (BreakpointResolver) { - /** - * Get the breakpoint span in given sourceFile - */ function spanInSourceFileAtLocation(sourceFile, position) { - // Cannot set breakpoint in dts file - if (sourceFile.flags & 2048 /* DeclarationFile */) { + if (sourceFile.flags & 2048) { return undefined; } var tokenAtLocation = ts.getTokenAtPosition(sourceFile, position); var lineOfPosition = sourceFile.getLineAndCharacterOfPosition(position).line; if (sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getStart()).line > lineOfPosition) { - // Get previous token if the token is returned starts on new line - // eg: let x =10; |--- cursor is here - // let y = 10; - // token at position will return let keyword on second line as the token but we would like to use - // token on same line if trailing trivia (comments or white spaces on same line) part of the last token on that line tokenAtLocation = ts.findPrecedingToken(tokenAtLocation.pos, sourceFile); - // Its a blank line if (!tokenAtLocation || sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getEnd()).line !== lineOfPosition) { return undefined; } } - // Cannot set breakpoint in ambient declarations if (ts.isInAmbientContext(tokenAtLocation)) { return undefined; } - // Get the span in the node based on its syntax return spanInNode(tokenAtLocation); function textSpan(startNode, endNode) { return ts.createTextSpanFromBounds(startNode.getStart(), (endNode || startNode).getEnd()); @@ -30483,210 +25892,170 @@ var ts; function spanInNode(node) { if (node) { if (ts.isExpression(node)) { - if (node.parent.kind === 185 /* DoStatement */) { - // Set span as if on while keyword + if (node.parent.kind === 185) { return spanInPreviousNode(node); } - if (node.parent.kind === 187 /* ForStatement */) { - // For now lets set the span on this expression, fix it later + if (node.parent.kind === 187) { return textSpan(node); } - if (node.parent.kind === 170 /* BinaryExpression */ && node.parent.operatorToken.kind === 23 /* CommaToken */) { - // if this is comma expression, the breakpoint is possible in this expression + if (node.parent.kind === 170 && node.parent.operatorToken.kind === 23) { return textSpan(node); } - if (node.parent.kind == 164 /* ArrowFunction */ && node.parent.body == node) { - // If this is body of arrow function, it is allowed to have the breakpoint + if (node.parent.kind == 164 && node.parent.body == node) { return textSpan(node); } } switch (node.kind) { - case 181 /* VariableStatement */: - // Span on first variable declaration + case 181: return spanInVariableDeclaration(node.declarationList.declarations[0]); - case 199 /* VariableDeclaration */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 199: + case 133: + case 132: return spanInVariableDeclaration(node); - case 130 /* Parameter */: + case 130: return spanInParameterDeclaration(node); - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 201: + case 135: + case 134: + case 137: + case 138: + case 136: + case 163: + case 164: return spanInFunctionDeclaration(node); - case 180 /* Block */: + case 180: if (ts.isFunctionBlock(node)) { return spanInFunctionBlock(node); } - // Fall through - case 207 /* ModuleBlock */: + case 207: return spanInBlock(node); - case 224 /* CatchClause */: + case 224: return spanInBlock(node.block); - case 183 /* ExpressionStatement */: - // span on the expression + case 183: return textSpan(node.expression); - case 192 /* ReturnStatement */: - // span on return keyword and expression if present + case 192: return textSpan(node.getChildAt(0), node.expression); - case 186 /* WhileStatement */: - // Span on while(...) + case 186: return textSpan(node, ts.findNextToken(node.expression, node)); - case 185 /* DoStatement */: - // span in statement of the do statement + case 185: return spanInNode(node.statement); - case 198 /* DebuggerStatement */: - // span on debugger keyword + case 198: return textSpan(node.getChildAt(0)); - case 184 /* IfStatement */: - // set on if(..) span + case 184: return textSpan(node, ts.findNextToken(node.expression, node)); - case 195 /* LabeledStatement */: - // span in statement + case 195: return spanInNode(node.statement); - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - // On break or continue keyword and label if present + case 191: + case 190: return textSpan(node.getChildAt(0), node.label); - case 187 /* ForStatement */: + case 187: return spanInForStatement(node); - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - // span on for (a in ...) + case 188: + case 189: return textSpan(node, ts.findNextToken(node.expression, node)); - case 194 /* SwitchStatement */: - // span on switch(...) + case 194: return textSpan(node, ts.findNextToken(node.expression, node)); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - // span in first statement of the clause + case 221: + case 222: return spanInNode(node.statements[0]); - case 197 /* TryStatement */: - // span in try block + case 197: return spanInBlock(node.tryBlock); - case 196 /* ThrowStatement */: - // span in throw ... + case 196: return textSpan(node, node.expression); - case 215 /* ExportAssignment */: - // span on export = id + case 215: return textSpan(node, node.expression); - case 209 /* ImportEqualsDeclaration */: - // import statement without including semicolon + case 209: return textSpan(node, node.moduleReference); - case 210 /* ImportDeclaration */: - // import statement without including semicolon + case 210: return textSpan(node, node.moduleSpecifier); - case 216 /* ExportDeclaration */: - // import statement without including semicolon + case 216: return textSpan(node, node.moduleSpecifier); - case 206 /* ModuleDeclaration */: - // span on complete module if it is instantiated - if (ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { + case 206: + if (ts.getModuleInstanceState(node) !== 1) { return undefined; } - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - // span on complete node + case 202: + case 205: + case 227: + case 158: + case 159: return textSpan(node); - case 193 /* WithStatement */: - // span in statement + case 193: return spanInNode(node.statement); - // No breakpoint in interface, type alias - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: + case 203: + case 204: return undefined; - // Tokens: - case 22 /* SemicolonToken */: - case 1 /* EndOfFileToken */: + case 22: + case 1: return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile)); - case 23 /* CommaToken */: + case 23: return spanInPreviousNode(node); - case 14 /* OpenBraceToken */: + case 14: return spanInOpenBraceToken(node); - case 15 /* CloseBraceToken */: + case 15: return spanInCloseBraceToken(node); - case 16 /* OpenParenToken */: + case 16: return spanInOpenParenToken(node); - case 17 /* CloseParenToken */: + case 17: return spanInCloseParenToken(node); - case 51 /* ColonToken */: + case 51: return spanInColonToken(node); - case 25 /* GreaterThanToken */: - case 24 /* LessThanToken */: + case 25: + case 24: return spanInGreaterThanOrLessThanToken(node); - // Keywords: - case 100 /* WhileKeyword */: + case 100: return spanInWhileKeyword(node); - case 76 /* ElseKeyword */: - case 68 /* CatchKeyword */: - case 81 /* FinallyKeyword */: + case 76: + case 68: + case 81: return spanInNextNode(node); default: - // If this is name of property assignment, set breakpoint in the initializer - if (node.parent.kind === 225 /* PropertyAssignment */ && node.parent.name === node) { + if (node.parent.kind === 225 && node.parent.name === node) { return spanInNode(node.parent.initializer); } - // Breakpoint in type assertion goes to its operand - if (node.parent.kind === 161 /* TypeAssertionExpression */ && node.parent.type === node) { + if (node.parent.kind === 161 && node.parent.type === node) { return spanInNode(node.parent.expression); } - // return type of function go to previous token if (ts.isFunctionLike(node.parent) && node.parent.type === node) { return spanInPreviousNode(node); } - // Default go to parent to set the breakpoint return spanInNode(node.parent); } } function spanInVariableDeclaration(variableDeclaration) { - // If declaration of for in statement, just set the span in parent - if (variableDeclaration.parent.parent.kind === 188 /* ForInStatement */ || - variableDeclaration.parent.parent.kind === 189 /* ForOfStatement */) { + if (variableDeclaration.parent.parent.kind === 188 || + variableDeclaration.parent.parent.kind === 189) { return spanInNode(variableDeclaration.parent.parent); } - var isParentVariableStatement = variableDeclaration.parent.parent.kind === 181 /* VariableStatement */; - var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 187 /* ForStatement */ && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); + var isParentVariableStatement = variableDeclaration.parent.parent.kind === 181; + var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 187 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); var declarations = isParentVariableStatement ? variableDeclaration.parent.parent.declarationList.declarations : isDeclarationOfForStatement ? variableDeclaration.parent.parent.initializer.declarations : undefined; - // Breakpoint is possible in variableDeclaration only if there is initialization - if (variableDeclaration.initializer || (variableDeclaration.flags & 1 /* Export */)) { + if (variableDeclaration.initializer || (variableDeclaration.flags & 1)) { if (declarations && declarations[0] === variableDeclaration) { if (isParentVariableStatement) { - // First declaration - include let keyword return textSpan(variableDeclaration.parent, variableDeclaration); } else { ts.Debug.assert(isDeclarationOfForStatement); - // Include let keyword from for statement declarations in the span return textSpan(ts.findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent), variableDeclaration); } } else { - // Span only on this declaration return textSpan(variableDeclaration); } } else if (declarations && declarations[0] !== variableDeclaration) { - // If we cant set breakpoint on this declaration, set it on previous one var indexOfCurrentDeclaration = ts.indexOf(declarations, variableDeclaration); return spanInVariableDeclaration(declarations[indexOfCurrentDeclaration - 1]); } } function canHaveSpanInParameterDeclaration(parameter) { - // Breakpoint is possible on parameter only if it has initializer, is a rest parameter, or has public or private modifier return !!parameter.initializer || parameter.dotDotDotToken !== undefined || - !!(parameter.flags & 16 /* Public */) || !!(parameter.flags & 32 /* Private */); + !!(parameter.flags & 16) || !!(parameter.flags & 32); } function spanInParameterDeclaration(parameter) { if (canHaveSpanInParameterDeclaration(parameter)) { @@ -30696,29 +26065,24 @@ var ts; var functionDeclaration = parameter.parent; var indexOfParameter = ts.indexOf(functionDeclaration.parameters, parameter); if (indexOfParameter) { - // Not a first parameter, go to previous parameter return spanInParameterDeclaration(functionDeclaration.parameters[indexOfParameter - 1]); } else { - // Set breakpoint in the function declaration body return spanInNode(functionDeclaration.body); } } } function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { - return !!(functionDeclaration.flags & 1 /* Export */) || - (functionDeclaration.parent.kind === 202 /* ClassDeclaration */ && functionDeclaration.kind !== 136 /* Constructor */); + return !!(functionDeclaration.flags & 1) || + (functionDeclaration.parent.kind === 202 && functionDeclaration.kind !== 136); } function spanInFunctionDeclaration(functionDeclaration) { - // No breakpoints in the function signature if (!functionDeclaration.body) { return undefined; } if (canFunctionHaveSpanInWholeDeclaration(functionDeclaration)) { - // Set the span on whole function declaration return textSpan(functionDeclaration); } - // Set span in function body return spanInNode(functionDeclaration.body); } function spanInFunctionBlock(block) { @@ -30730,26 +26094,23 @@ var ts; } function spanInBlock(block) { switch (block.parent.kind) { - case 206 /* ModuleDeclaration */: - if (ts.getModuleInstanceState(block.parent) !== 1 /* Instantiated */) { + case 206: + if (ts.getModuleInstanceState(block.parent) !== 1) { return undefined; } - // Set on parent if on same line otherwise on first statement - case 186 /* WhileStatement */: - case 184 /* IfStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 186: + case 184: + case 188: + case 189: return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); - // Set span on previous token if it starts on same line otherwise on the first statement of the block - case 187 /* ForStatement */: + case 187: return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]); } - // Default action is to set on first statement return spanInNode(block.statements[0]); } function spanInForStatement(forStatement) { if (forStatement.initializer) { - if (forStatement.initializer.kind === 200 /* VariableDeclarationList */) { + if (forStatement.initializer.kind === 200) { var variableDeclarationList = forStatement.initializer; if (variableDeclarationList.declarations.length > 0) { return spanInNode(variableDeclarationList.declarations[0]); @@ -30766,103 +26127,87 @@ var ts; return textSpan(forStatement.incrementor); } } - // Tokens: function spanInOpenBraceToken(node) { switch (node.parent.kind) { - case 205 /* EnumDeclaration */: + case 205: var enumDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); - case 202 /* ClassDeclaration */: + case 202: var classDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); - case 208 /* CaseBlock */: + case 208: return spanInNodeIfStartsOnSameLine(node.parent.parent, node.parent.clauses[0]); } - // Default to parent node return spanInNode(node.parent); } function spanInCloseBraceToken(node) { switch (node.parent.kind) { - case 207 /* ModuleBlock */: - // If this is not instantiated module block no bp span - if (ts.getModuleInstanceState(node.parent.parent) !== 1 /* Instantiated */) { + case 207: + if (ts.getModuleInstanceState(node.parent.parent) !== 1) { return undefined; } - case 205 /* EnumDeclaration */: - case 202 /* ClassDeclaration */: - // Span on close brace token + case 205: + case 202: return textSpan(node); - case 180 /* Block */: + case 180: if (ts.isFunctionBlock(node.parent)) { - // Span on close brace token return textSpan(node); } - // fall through. - case 224 /* CatchClause */: - return spanInNode(node.parent.statements[node.parent.statements.length - 1]); + case 224: + return spanInNode(ts.lastOrUndefined(node.parent.statements)); ; - case 208 /* CaseBlock */: - // breakpoint in last statement of the last clause + case 208: var caseBlock = node.parent; - var lastClause = caseBlock.clauses[caseBlock.clauses.length - 1]; + var lastClause = ts.lastOrUndefined(caseBlock.clauses); if (lastClause) { - return spanInNode(lastClause.statements[lastClause.statements.length - 1]); + return spanInNode(ts.lastOrUndefined(lastClause.statements)); } return undefined; - // Default to parent node default: return spanInNode(node.parent); } } function spanInOpenParenToken(node) { - if (node.parent.kind === 185 /* DoStatement */) { - // Go to while keyword and do action instead + if (node.parent.kind === 185) { return spanInPreviousNode(node); } - // Default to parent node return spanInNode(node.parent); } function spanInCloseParenToken(node) { - // Is this close paren token of parameter list, set span in previous token switch (node.parent.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: - case 187 /* ForStatement */: + case 163: + case 201: + case 164: + case 135: + case 134: + case 137: + case 138: + case 136: + case 186: + case 185: + case 187: return spanInPreviousNode(node); - // Default to parent node default: return spanInNode(node.parent); } - // Default to parent node return spanInNode(node.parent); } function spanInColonToken(node) { - // Is this : specifying return annotation of the function declaration - if (ts.isFunctionLike(node.parent) || node.parent.kind === 225 /* PropertyAssignment */) { + if (ts.isFunctionLike(node.parent) || node.parent.kind === 225) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInGreaterThanOrLessThanToken(node) { - if (node.parent.kind === 161 /* TypeAssertionExpression */) { + if (node.parent.kind === 161) { return spanInNode(node.parent.expression); } return spanInNode(node.parent); } function spanInWhileKeyword(node) { - if (node.parent.kind === 185 /* DoStatement */) { - // Set span on while expression + if (node.parent.kind === 185) { return textSpan(node, ts.findNextToken(node.parent.expression, node.parent)); } - // Default to parent node return spanInNode(node.parent); } } @@ -30870,7 +26215,6 @@ var ts; BreakpointResolver.spanInSourceFileAtLocation = spanInSourceFileAtLocation; })(BreakpointResolver = ts.BreakpointResolver || (ts.BreakpointResolver = {})); })(ts || (ts = {})); -/* @internal */ var ts; (function (ts) { var OutliningElementsCollector; @@ -30909,9 +26253,7 @@ var ts; var singleLineCommentCount = 0; for (var _i = 0; _i < comments.length; _i++) { var currentComment = comments[_i]; - // For single line comments, combine consecutive ones (2 or more) into - // a single span from the start of the first till the end of the last - if (currentComment.kind === 2 /* SingleLineCommentTrivia */) { + if (currentComment.kind === 2) { if (isFirstSingleLineComment) { firstSingleLineCommentStart = currentComment.pos; } @@ -30919,7 +26261,7 @@ var ts; lastSingleLineCommentEnd = currentComment.end; singleLineCommentCount++; } - else if (currentComment.kind === 3 /* MultiLineCommentTrivia */) { + else if (currentComment.kind === 3) { combineAndAddMultipleSingleLineComments(singleLineCommentCount, firstSingleLineCommentStart, lastSingleLineCommentEnd); addOutliningSpanComments(currentComment, false); singleLineCommentCount = 0; @@ -30931,18 +26273,17 @@ var ts; } } function combineAndAddMultipleSingleLineComments(count, start, end) { - // Only outline spans of two or more consecutive single line comments if (count > 1) { var multipleSingleLineComments = { pos: start, end: end, - kind: 2 /* SingleLineCommentTrivia */ + kind: 2 }; addOutliningSpanComments(multipleSingleLineComments, false); } } function autoCollapse(node) { - return ts.isFunctionBlock(node) && node.parent.kind !== 164 /* ArrowFunction */; + return ts.isFunctionBlock(node) && node.parent.kind !== 164; } var depth = 0; var maxDepth = 20; @@ -30954,42 +26295,36 @@ var ts; addOutliningForLeadingCommentsForNode(n); } switch (n.kind) { - case 180 /* Block */: + case 180: if (!ts.isFunctionBlock(n)) { var parent_6 = n.parent; - var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); - var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); - // Check if the block is standalone, or 'attached' to some parent statement. - // If the latter, we want to collaps the block, but consider its hint span - // to be the entire span of the parent. - if (parent_6.kind === 185 /* DoStatement */ || - parent_6.kind === 188 /* ForInStatement */ || - parent_6.kind === 189 /* ForOfStatement */ || - parent_6.kind === 187 /* ForStatement */ || - parent_6.kind === 184 /* IfStatement */ || - parent_6.kind === 186 /* WhileStatement */ || - parent_6.kind === 193 /* WithStatement */ || - parent_6.kind === 224 /* CatchClause */) { + var openBrace = ts.findChildOfKind(n, 14, sourceFile); + var closeBrace = ts.findChildOfKind(n, 15, sourceFile); + if (parent_6.kind === 185 || + parent_6.kind === 188 || + parent_6.kind === 189 || + parent_6.kind === 187 || + parent_6.kind === 184 || + parent_6.kind === 186 || + parent_6.kind === 193 || + parent_6.kind === 224) { addOutliningSpan(parent_6, openBrace, closeBrace, autoCollapse(n)); break; } - if (parent_6.kind === 197 /* TryStatement */) { - // Could be the try-block, or the finally-block. + if (parent_6.kind === 197) { var tryStatement = parent_6; if (tryStatement.tryBlock === n) { addOutliningSpan(parent_6, openBrace, closeBrace, autoCollapse(n)); break; } else if (tryStatement.finallyBlock === n) { - var finallyKeyword = ts.findChildOfKind(tryStatement, 81 /* FinallyKeyword */, sourceFile); + var finallyKeyword = ts.findChildOfKind(tryStatement, 81, sourceFile); if (finallyKeyword) { addOutliningSpan(finallyKeyword, openBrace, closeBrace, autoCollapse(n)); break; } } } - // Block was a standalone block. In this case we want to only collapse - // the span of the block, independent of any parent span. var span = ts.createTextSpanFromBounds(n.getStart(), n.end); elements.push({ textSpan: span, @@ -30999,26 +26334,25 @@ var ts; }); break; } - // Fallthrough. - case 207 /* ModuleBlock */: { - var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); - var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); + case 207: { + var openBrace = ts.findChildOfKind(n, 14, sourceFile); + var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n)); break; } - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 155 /* ObjectLiteralExpression */: - case 208 /* CaseBlock */: { - var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); - var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); + case 202: + case 203: + case 205: + case 155: + case 208: { + var openBrace = ts.findChildOfKind(n, 14, sourceFile); + var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n)); break; } - case 154 /* ArrayLiteralExpression */: - var openBracket = ts.findChildOfKind(n, 18 /* OpenBracketToken */, sourceFile); - var closeBracket = ts.findChildOfKind(n, 19 /* CloseBracketToken */, sourceFile); + case 154: + var openBracket = ts.findChildOfKind(n, 18, sourceFile); + var closeBracket = ts.findChildOfKind(n, 19, sourceFile); addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n)); break; } @@ -31032,7 +26366,6 @@ var ts; OutliningElementsCollector.collectElements = collectElements; })(OutliningElementsCollector = ts.OutliningElementsCollector || (ts.OutliningElementsCollector = {})); })(ts || (ts = {})); -/* @internal */ var ts; (function (ts) { var NavigateTo; @@ -31040,23 +26373,18 @@ var ts; function getNavigateToItems(program, cancellationToken, searchValue, maxResultCount) { var patternMatcher = ts.createPatternMatcher(searchValue); var rawItems = []; - // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[] ts.forEach(program.getSourceFiles(), function (sourceFile) { cancellationToken.throwIfCancellationRequested(); var nameToDeclarations = sourceFile.getNamedDeclarations(); for (var name_22 in nameToDeclarations) { var declarations = ts.getProperty(nameToDeclarations, name_22); if (declarations) { - // First do a quick check to see if the name of the declaration matches the - // last portion of the (possibly) dotted name they're searching for. var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_22); if (!matches) { continue; } for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; - // It was a match! If the pattern has dots in it, then also see if the - // declaration container matches as well. if (patternMatcher.patternContainsDots) { var containers = getContainers(declaration); if (!containers) { @@ -31082,7 +26410,6 @@ var ts; return items; function allMatchesAreCaseSensitive(matches) { ts.Debug.assert(matches.length > 0); - // This is a case sensitive match, only if all the submatches were case sensitive. for (var _i = 0; _i < matches.length; _i++) { var match = matches[_i]; if (!match.isCaseSensitive) { @@ -31093,9 +26420,9 @@ var ts; } function getTextOfIdentifierOrLiteral(node) { if (node) { - if (node.kind === 65 /* Identifier */ || - node.kind === 8 /* StringLiteral */ || - node.kind === 7 /* NumericLiteral */) { + if (node.kind === 65 || + node.kind === 8 || + node.kind === 7) { return node.text; } } @@ -31107,19 +26434,15 @@ var ts; if (text !== undefined) { containers.unshift(text); } - else if (declaration.name.kind === 128 /* ComputedPropertyName */) { + else if (declaration.name.kind === 128) { return tryAddComputedPropertyName(declaration.name.expression, containers, true); } else { - // Don't know how to add this. return false; } } return true; } - // Only added the names of computed properties if they're simple dotted expressions, like: - // - // [X.Y.Z]() { } function tryAddComputedPropertyName(expression, containers, includeLastPortion) { var text = getTextOfIdentifierOrLiteral(expression); if (text !== undefined) { @@ -31128,7 +26451,7 @@ var ts; } return true; } - if (expression.kind === 156 /* PropertyAccessExpression */) { + if (expression.kind === 156) { var propertyAccess = expression; if (includeLastPortion) { containers.unshift(propertyAccess.name.text); @@ -31139,14 +26462,11 @@ var ts; } function getContainers(declaration) { var containers = []; - // First, if we started with a computed property name, then add all but the last - // portion into the container array. - if (declaration.name.kind === 128 /* ComputedPropertyName */) { + if (declaration.name.kind === 128) { if (!tryAddComputedPropertyName(declaration.name.expression, containers, false)) { return undefined; } } - // Now, walk up our containers, adding all their names to the container array. declaration = ts.getContainerNode(declaration); while (declaration) { if (!tryAddSingleDeclarationName(declaration, containers)) { @@ -31168,13 +26488,8 @@ var ts; } return bestMatchKind; } - // This means "compare in a case insensitive manner." var baseSensitivity = { sensitivity: "base" }; function compareNavigateToItems(i1, i2) { - // TODO(cyrusn): get the gamut of comparisons that VS already uses here. - // Right now we just sort by kind first, and then by name of the item. - // We first sort case insensitively. So "Aaa" will come before "bar". - // Then we sort case sensitively, so "aaa" will come before "Aaa". return i1.matchKind - i2.matchKind || i1.name.localeCompare(i2.name, undefined, baseSensitivity) || i1.name.localeCompare(i2.name); @@ -31190,7 +26505,6 @@ var ts; isCaseSensitive: rawItem.isCaseSensitive, fileName: rawItem.fileName, textSpan: ts.createTextSpanFromBounds(declaration.getStart(), declaration.getEnd()), - // TODO(jfreeman): What should be the containerName when the container has a computed name? containerName: container && container.name ? container.name.text : "", containerKind: container && container.name ? ts.getNodeKind(container) : "" }; @@ -31200,34 +26514,26 @@ var ts; })(NavigateTo = ts.NavigateTo || (ts.NavigateTo = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var NavigationBar; (function (NavigationBar) { function getNavigationBarItems(sourceFile) { - // If the source file has any child items, then it included in the tree - // and takes lexical ownership of all other top-level items. var hasGlobalNode = false; return getItemsWorker(getTopLevelNodes(sourceFile), createTopLevelItem); function getIndent(node) { - // If we have a global node in the tree, - // then it adds an extra layer of depth to all subnodes. var indent = hasGlobalNode ? 1 : 0; var current = node.parent; while (current) { switch (current.kind) { - case 206 /* ModuleDeclaration */: - // If we have a module declared as A.B.C, it is more "intuitive" - // to say it only has a single layer of depth + case 206: do { current = current.parent; - } while (current.kind === 206 /* ModuleDeclaration */); - // fall through - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: + } while (current.kind === 206); + case 202: + case 205: + case 203: + case 201: indent++; } current = current.parent; @@ -31238,33 +26544,26 @@ var ts; var childNodes = []; function visit(node) { switch (node.kind) { - case 181 /* VariableStatement */: + case 181: ts.forEach(node.declarationList.declarations, visit); break; - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: + case 151: + case 152: ts.forEach(node.elements, visit); break; - case 216 /* ExportDeclaration */: - // Handle named exports case e.g.: - // export {a, b as B} from "mod"; + case 216: if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210 /* ImportDeclaration */: + case 210: var importClause = node.importClause; if (importClause) { - // Handle default import case e.g.: - // import d from "mod"; if (importClause.name) { childNodes.push(importClause); } - // Handle named bindings in imports e.g.: - // import * as NS from "mod"; - // import {a, b as B} from "mod"; if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 212) { childNodes.push(importClause.namedBindings); } else { @@ -31273,38 +26572,24 @@ var ts; } } break; - case 153 /* BindingElement */: - case 199 /* VariableDeclaration */: + case 153: + case 199: if (ts.isBindingPattern(node.name)) { visit(node.name); break; } - // Fall through - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 201 /* FunctionDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 202: + case 205: + case 203: + case 206: + case 201: + case 209: + case 214: + case 218: childNodes.push(node); break; } } - //for (let i = 0, n = nodes.length; i < n; i++) { - // let node = nodes[i]; - // if (node.kind === SyntaxKind.ClassDeclaration || - // node.kind === SyntaxKind.EnumDeclaration || - // node.kind === SyntaxKind.InterfaceDeclaration || - // node.kind === SyntaxKind.ModuleDeclaration || - // node.kind === SyntaxKind.FunctionDeclaration) { - // childNodes.push(node); - // } - // else if (node.kind === SyntaxKind.VariableStatement) { - // childNodes.push.apply(childNodes, (node).declarations); - // } - //} ts.forEach(nodes, visit); return sortNodes(childNodes); } @@ -31335,17 +26620,17 @@ var ts; for (var _i = 0; _i < nodes.length; _i++) { var node = nodes[_i]; switch (node.kind) { - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: + case 202: + case 205: + case 203: topLevelNodes.push(node); break; - case 206 /* ModuleDeclaration */: + case 206: var moduleDeclaration = node; topLevelNodes.push(node); addTopLevelNodes(getInnermostModule(moduleDeclaration).body.statements, topLevelNodes); break; - case 201 /* FunctionDeclaration */: + case 201: var functionDeclaration = node; if (isTopLevelFunctionDeclaration(functionDeclaration)) { topLevelNodes.push(node); @@ -31356,16 +26641,11 @@ var ts; } } function isTopLevelFunctionDeclaration(functionDeclaration) { - if (functionDeclaration.kind === 201 /* FunctionDeclaration */) { - // A function declaration is 'top level' if it contains any function declarations - // within it. - if (functionDeclaration.body && functionDeclaration.body.kind === 180 /* Block */) { - // Proper function declarations can only have identifier names - if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 201 /* FunctionDeclaration */ && !isEmpty(s.name.text); })) { + if (functionDeclaration.kind === 201) { + if (functionDeclaration.body && functionDeclaration.body.kind === 180) { + if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 201 && !isEmpty(s.name.text); })) { return true; } - // Or if it is not parented by another function. i.e all functions - // at module scope are 'top level'. if (!ts.isFunctionBlock(functionDeclaration.parent)) { return true; } @@ -31384,7 +26664,6 @@ var ts; var key = item.text + "-" + item.kind + "-" + item.indent; var itemWithSameName = keyToItem[key]; if (itemWithSameName) { - // We had an item with the same name. Merge these items together. merge(itemWithSameName, item); } else { @@ -31397,68 +26676,62 @@ var ts; return items; } function merge(target, source) { - // First, add any spans in the source to the target. target.spans.push.apply(target.spans, source.spans); if (source.childItems) { if (!target.childItems) { target.childItems = []; } - // Next, recursively merge or add any children in the source as appropriate. outer: for (var _i = 0, _a = source.childItems; _i < _a.length; _i++) { var sourceChild = _a[_i]; for (var _b = 0, _c = target.childItems; _b < _c.length; _b++) { var targetChild = _c[_b]; if (targetChild.text === sourceChild.text && targetChild.kind === sourceChild.kind) { - // Found a match. merge them. merge(targetChild, sourceChild); continue outer; } } - // Didn't find a match, just add this child to the list. target.childItems.push(sourceChild); } } } function createChildItem(node) { switch (node.kind) { - case 130 /* Parameter */: + case 130: if (ts.isBindingPattern(node.name)) { break; } - if ((node.flags & 499 /* Modifier */) === 0) { + if ((node.flags & 499) === 0) { return undefined; } return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); - case 137 /* GetAccessor */: + case 137: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); - case 138 /* SetAccessor */: + case 138: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); - case 141 /* IndexSignature */: + case 141: return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); - case 227 /* EnumMember */: + case 227: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 139 /* CallSignature */: + case 139: return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); - case 140 /* ConstructSignature */: + case 140: return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 133: + case 132: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 201 /* FunctionDeclaration */: + case 201: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.functionElement); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 199: + case 153: var variableDeclarationNode; var name_23; - if (node.kind === 153 /* BindingElement */) { + if (node.kind === 153) { name_23 = node.name; variableDeclarationNode = node; - // binding elements are added only for variable declarations - // bubble up to the containing variable declaration - while (variableDeclarationNode && variableDeclarationNode.kind !== 199 /* VariableDeclaration */) { + while (variableDeclarationNode && variableDeclarationNode.kind !== 199) { variableDeclarationNode = variableDeclarationNode.parent; } ts.Debug.assert(variableDeclarationNode !== undefined); @@ -31477,13 +26750,13 @@ var ts; else { return createItem(node, getTextOfNode(name_23), ts.ScriptElementKind.variableElement); } - case 136 /* Constructor */: + case 136: return createItem(node, "constructor", ts.ScriptElementKind.constructorImplementationElement); - case 218 /* ExportSpecifier */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: + case 218: + case 214: + case 209: + case 211: + case 212: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.alias); } return undefined; @@ -31513,29 +26786,27 @@ var ts; } function createTopLevelItem(node) { switch (node.kind) { - case 228 /* SourceFile */: + case 228: return createSourceFileItem(node); - case 202 /* ClassDeclaration */: + case 202: return createClassItem(node); - case 205 /* EnumDeclaration */: + case 205: return createEnumItem(node); - case 203 /* InterfaceDeclaration */: + case 203: return createIterfaceItem(node); - case 206 /* ModuleDeclaration */: + case 206: return createModuleItem(node); - case 201 /* FunctionDeclaration */: + case 201: return createFunctionItem(node); } return undefined; function getModuleName(moduleDeclaration) { - // We want to maintain quotation marks. - if (moduleDeclaration.name.kind === 8 /* StringLiteral */) { + if (moduleDeclaration.name.kind === 8) { return getTextOfNode(moduleDeclaration.name); } - // Otherwise, we need to aggregate each identifier to build up the qualified name. var result = []; result.push(moduleDeclaration.name.text); - while (moduleDeclaration.body && moduleDeclaration.body.kind === 206 /* ModuleDeclaration */) { + while (moduleDeclaration.body && moduleDeclaration.body.kind === 206) { moduleDeclaration = moduleDeclaration.body; result.push(moduleDeclaration.name.text); } @@ -31547,7 +26818,7 @@ var ts; return getNavigationBarItem(moduleName, ts.ScriptElementKind.moduleElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } function createFunctionItem(node) { - if (node.body && node.body.kind === 180 /* Block */) { + if (node.body && node.body.kind === 180) { var childItems = getItemsWorker(sortNodes(node.body.statements), createChildItem); return getNavigationBarItem(!node.name ? "default" : node.name.text, ts.ScriptElementKind.functionElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } @@ -31568,11 +26839,8 @@ var ts; var childItems; if (node.members) { var constructor = ts.forEach(node.members, function (member) { - return member.kind === 136 /* Constructor */ && member; + return member.kind === 136 && member; }); - // Add the constructor parameters in as children of the class (for property parameters). - // Note that *all non-binding pattern named* parameters will be added to the nodes array, but parameters that - // are not properties will be filtered out later by createChildItem. var nodes = removeDynamicallyNamedProperties(node); if (constructor) { nodes.push.apply(nodes, ts.filter(constructor.parameters, function (p) { return !ts.isBindingPattern(p.name); })); @@ -31592,22 +26860,19 @@ var ts; } } function removeComputedProperties(node) { - return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 128 /* ComputedPropertyName */; }); + return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 128; }); } - /** - * Like removeComputedProperties, but retains the properties with well known symbol names - */ function removeDynamicallyNamedProperties(node) { return ts.filter(node.members, function (member) { return !ts.hasDynamicName(member); }); } function getInnermostModule(node) { - while (node.body.kind === 206 /* ModuleDeclaration */) { + while (node.body.kind === 206) { node = node.body; } return node; } function getNodeSpan(node) { - return node.kind === 228 /* SourceFile */ + return node.kind === 228 ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); } @@ -31618,10 +26883,8 @@ var ts; NavigationBar.getNavigationBarItems = getNavigationBarItems; })(NavigationBar = ts.NavigationBar || (ts.NavigationBar = {})); })(ts || (ts = {})); -/* @internal */ var ts; (function (ts) { - // Note(cyrusn): this enum is ordered from strongest match type to weakest match type. (function (PatternMatchKind) { PatternMatchKind[PatternMatchKind["exact"] = 0] = "exact"; PatternMatchKind[PatternMatchKind["prefix"] = 1] = "prefix"; @@ -31638,10 +26901,6 @@ var ts; }; } function createPatternMatcher(pattern) { - // We'll often see the same candidate string many times when searching (For example, when - // we see the name of a module that is used everywhere, or the name of an overload). As - // such, we cache the information we compute about the candidate for the life of this - // pattern matcher so we don't have to compute it multiple times. var stringToWordSpans = {}; pattern = pattern.trim(); var fullPatternSegment = createSegment(pattern); @@ -31652,7 +26911,6 @@ var ts; getMatchesForLastSegmentOfPattern: getMatchesForLastSegmentOfPattern, patternContainsDots: dotSeparatedSegments.length > 1 }; - // Quick checks so we can bail out when asked to match a candidate. function skipMatch(candidate) { return invalidPattern || !candidate; } @@ -31666,36 +26924,24 @@ var ts; if (skipMatch(candidate)) { return undefined; } - // First, check that the last part of the dot separated pattern matches the name of the - // candidate. If not, then there's no point in proceeding and doing the more - // expensive work. var candidateMatch = matchSegment(candidate, ts.lastOrUndefined(dotSeparatedSegments)); if (!candidateMatch) { return undefined; } candidateContainers = candidateContainers || []; - // -1 because the last part was checked against the name, and only the rest - // of the parts are checked against the container. if (dotSeparatedSegments.length - 1 > candidateContainers.length) { - // There weren't enough container parts to match against the pattern parts. - // So this definitely doesn't match. return undefined; } - // So far so good. Now break up the container for the candidate and check if all - // the dotted parts match up correctly. var totalMatch = candidateMatch; for (var i = dotSeparatedSegments.length - 2, j = candidateContainers.length - 1; i >= 0; i--, j--) { var segment = dotSeparatedSegments[i]; var containerName = candidateContainers[j]; var containerMatch = matchSegment(containerName, segment); if (!containerMatch) { - // This container didn't match the pattern piece. So there's no match at all. return undefined; } ts.addRange(totalMatch, containerMatch); } - // Success, this symbol's full name matched against the dotted name the user was asking - // about. return totalMatch; } function getWordSpans(word) { @@ -31708,46 +26954,30 @@ var ts; var index = indexOfIgnoringCase(candidate, chunk.textLowerCase); if (index === 0) { if (chunk.text.length === candidate.length) { - // a) Check if the part matches the candidate entirely, in an case insensitive or - // sensitive manner. If it does, return that there was an exact match. return createPatternMatch(PatternMatchKind.exact, punctuationStripped, candidate === chunk.text); } else { - // b) Check if the part is a prefix of the candidate, in a case insensitive or sensitive - // manner. If it does, return that there was a prefix match. return createPatternMatch(PatternMatchKind.prefix, punctuationStripped, startsWith(candidate, chunk.text)); } } var isLowercase = chunk.isLowerCase; if (isLowercase) { if (index > 0) { - // c) If the part is entirely lowercase, then check if it is contained anywhere in the - // candidate in a case insensitive manner. If so, return that there was a substring - // match. - // - // Note: We only have a substring match if the lowercase part is prefix match of some - // word part. That way we don't match something like 'Class' when the user types 'a'. - // But we would match 'FooAttribute' (since 'Attribute' starts with 'a'). var wordSpans = getWordSpans(candidate); for (var _i = 0; _i < wordSpans.length; _i++) { var span = wordSpans[_i]; if (partStartsWith(candidate, span, chunk.text, true)) { - return createPatternMatch(PatternMatchKind.substring, punctuationStripped, - /*isCaseSensitive:*/ partStartsWith(candidate, span, chunk.text, false)); + return createPatternMatch(PatternMatchKind.substring, punctuationStripped, partStartsWith(candidate, span, chunk.text, false)); } } } } else { - // d) If the part was not entirely lowercase, then check if it is contained in the - // candidate in a case *sensitive* manner. If so, return that there was a substring - // match. if (candidate.indexOf(chunk.text) > 0) { return createPatternMatch(PatternMatchKind.substring, punctuationStripped, true); } } if (!isLowercase) { - // e) If the part was not entirely lowercase, then attempt a camel cased match as well. if (chunk.characterSpans.length > 0) { var candidateParts = getWordSpans(candidate); var camelCaseWeight = tryCamelCaseMatch(candidate, candidateParts, chunk, false); @@ -31761,12 +26991,6 @@ var ts; } } if (isLowercase) { - // f) Is the pattern a substring of the candidate starting on one of the candidate's word boundaries? - // We could check every character boundary start of the candidate for the pattern. However, that's - // an m * n operation in the wost case. Instead, find the first instance of the pattern - // substring, and see if it starts on a capital letter. It seems unlikely that the user will try to - // filter the list based on a substring that starts on a capital letter and also with a lowercase one. - // (Pattern: fogbar, Candidate: quuxfogbarFogBar). if (chunk.text.length < candidate.length) { if (index > 0 && isUpperCaseLetter(candidate.charCodeAt(index))) { return createPatternMatch(PatternMatchKind.substring, punctuationStripped, false); @@ -31778,67 +27002,23 @@ var ts; function containsSpaceOrAsterisk(text) { for (var i = 0; i < text.length; i++) { var ch = text.charCodeAt(i); - if (ch === 32 /* space */ || ch === 42 /* asterisk */) { + if (ch === 32 || ch === 42) { return true; } } return false; } function matchSegment(candidate, segment) { - // First check if the segment matches as is. This is also useful if the segment contains - // characters we would normally strip when splitting into parts that we also may want to - // match in the candidate. For example if the segment is "@int" and the candidate is - // "@int", then that will show up as an exact match here. - // - // Note: if the segment contains a space or an asterisk then we must assume that it's a - // multi-word segment. if (!containsSpaceOrAsterisk(segment.totalTextChunk.text)) { var match = matchTextChunk(candidate, segment.totalTextChunk, false); if (match) { return [match]; } } - // The logic for pattern matching is now as follows: - // - // 1) Break the segment passed in into words. Breaking is rather simple and a - // good way to think about it that if gives you all the individual alphanumeric words - // of the pattern. - // - // 2) For each word try to match the word against the candidate value. - // - // 3) Matching is as follows: - // - // a) Check if the word matches the candidate entirely, in an case insensitive or - // sensitive manner. If it does, return that there was an exact match. - // - // b) Check if the word is a prefix of the candidate, in a case insensitive or - // sensitive manner. If it does, return that there was a prefix match. - // - // c) If the word is entirely lowercase, then check if it is contained anywhere in the - // candidate in a case insensitive manner. If so, return that there was a substring - // match. - // - // Note: We only have a substring match if the lowercase part is prefix match of - // some word part. That way we don't match something like 'Class' when the user - // types 'a'. But we would match 'FooAttribute' (since 'Attribute' starts with - // 'a'). - // - // d) If the word was not entirely lowercase, then check if it is contained in the - // candidate in a case *sensitive* manner. If so, return that there was a substring - // match. - // - // e) If the word was not entirely lowercase, then attempt a camel cased match as - // well. - // - // f) The word is all lower case. Is it a case insensitive substring of the candidate starting - // on a part boundary of the candidate? - // - // Only if all words have some sort of match is the pattern considered matched. var subWordTextChunks = segment.subWordTextChunks; var matches = undefined; for (var _i = 0; _i < subWordTextChunks.length; _i++) { var subWordTextChunk = subWordTextChunks[_i]; - // Try to match the candidate with this word var result = matchTextChunk(candidate, subWordTextChunk, true); if (!result) { return undefined; @@ -31852,7 +27032,6 @@ var ts; var patternPartStart = patternSpan ? patternSpan.start : 0; var patternPartLength = patternSpan ? patternSpan.length : pattern.length; if (patternPartLength > candidateSpan.length) { - // Pattern part is longer than the candidate part. There can never be a match. return false; } if (ignoreCase) { @@ -31877,45 +27056,29 @@ var ts; } function tryCamelCaseMatch(candidate, candidateParts, chunk, ignoreCase) { var chunkCharacterSpans = chunk.characterSpans; - // Note: we may have more pattern parts than candidate parts. This is because multiple - // pattern parts may match a candidate part. For example "SiUI" against "SimpleUI". - // We'll have 3 pattern parts Si/U/I against two candidate parts Simple/UI. However, U - // and I will both match in UI. var currentCandidate = 0; var currentChunkSpan = 0; var firstMatch = undefined; var contiguous = undefined; while (true) { - // Let's consider our termination cases if (currentChunkSpan === chunkCharacterSpans.length) { - // We did match! We shall assign a weight to this var weight = 0; - // Was this contiguous? if (contiguous) { weight += 1; } - // Did we start at the beginning of the candidate? if (firstMatch === 0) { weight += 2; } return weight; } else if (currentCandidate === candidateParts.length) { - // No match, since we still have more of the pattern to hit return undefined; } var candidatePart = candidateParts[currentCandidate]; var gotOneMatchThisCandidate = false; - // Consider the case of matching SiUI against SimpleUIElement. The candidate parts - // will be Simple/UI/Element, and the pattern parts will be Si/U/I. We'll match 'Si' - // against 'Simple' first. Then we'll match 'U' against 'UI'. However, we want to - // still keep matching pattern parts against that candidate part. for (; currentChunkSpan < chunkCharacterSpans.length; currentChunkSpan++) { var chunkCharacterSpan = chunkCharacterSpans[currentChunkSpan]; if (gotOneMatchThisCandidate) { - // We've already gotten one pattern part match in this candidate. We will - // only continue trying to consumer pattern parts if the last part and this - // part are both upper case. if (!isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan - 1].start)) || !isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan].start))) { break; @@ -31926,30 +27089,17 @@ var ts; } gotOneMatchThisCandidate = true; firstMatch = firstMatch === undefined ? currentCandidate : firstMatch; - // If we were contiguous, then keep that value. If we weren't, then keep that - // value. If we don't know, then set the value to 'true' as an initial match is - // obviously contiguous. contiguous = contiguous === undefined ? true : contiguous; candidatePart = ts.createTextSpan(candidatePart.start + chunkCharacterSpan.length, candidatePart.length - chunkCharacterSpan.length); } - // Check if we matched anything at all. If we didn't, then we need to unset the - // contiguous bit if we currently had it set. - // If we haven't set the bit yet, then that means we haven't matched anything so - // far, and we don't want to change that. if (!gotOneMatchThisCandidate && contiguous !== undefined) { contiguous = false; } - // Move onto the next candidate. currentCandidate++; } } } ts.createPatternMatcher = createPatternMatcher; - // Helper function to compare two matches to determine which is better. Matches are first - // ordered by kind (so all prefix matches always beat all substring matches). Then, if the - // match is a camel case match, the relative weights of the match are used to determine - // which is better (with a greater weight being better). Then if the match is of the same - // type, then a case sensitive match is considered better than an insensitive one. function patternMatchCompareTo(match1, match2) { return compareType(match1, match2) || compareCamelCase(match1, match2) || @@ -31957,8 +27107,6 @@ var ts; comparePunctuation(match1, match2); } function comparePunctuation(result1, result2) { - // Consider a match to be better if it was successful without stripping punctuation - // versus a match that had to strip punctuation to succeed. if (result1.punctuationStripped !== result2.punctuationStripped) { return result1.punctuationStripped ? 1 : -1; } @@ -31975,8 +27123,6 @@ var ts; } function compareCamelCase(result1, result2) { if (result1.kind === PatternMatchKind.camelCase && result2.kind === PatternMatchKind.camelCase) { - // Swap the values here. If result1 has a higher weight, then we want it to come - // first. return result2.camelCaseWeight - result1.camelCaseWeight; } return 0; @@ -31987,33 +27133,26 @@ var ts; subWordTextChunks: breakPatternIntoTextChunks(text) }; } - // A segment is considered invalid if we couldn't find any words in it. function segmentIsInvalid(segment) { return segment.subWordTextChunks.length === 0; } function isUpperCaseLetter(ch) { - // Fast check for the ascii range. - if (ch >= 65 /* A */ && ch <= 90 /* Z */) { + if (ch >= 65 && ch <= 90) { return true; } - if (ch < 127 /* maxAsciiCharacter */ || !ts.isUnicodeIdentifierStart(ch, 2 /* Latest */)) { + if (ch < 127 || !ts.isUnicodeIdentifierStart(ch, 2)) { return false; } - // TODO: find a way to determine this for any unicode characters in a - // non-allocating manner. var str = String.fromCharCode(ch); return str === str.toUpperCase(); } function isLowerCaseLetter(ch) { - // Fast check for the ascii range. - if (ch >= 97 /* a */ && ch <= 122 /* z */) { + if (ch >= 97 && ch <= 122) { return true; } - if (ch < 127 /* maxAsciiCharacter */ || !ts.isUnicodeIdentifierStart(ch, 2 /* Latest */)) { + if (ch < 127 || !ts.isUnicodeIdentifierStart(ch, 2)) { return false; } - // TODO: find a way to determine this for any unicode characters in a - // non-allocating manner. var str = String.fromCharCode(ch); return str === str.toLowerCase(); } @@ -32033,7 +27172,6 @@ var ts; } return true; } - // Assumes 'value' is already lowercase. function indexOfIgnoringCase(string, value) { for (var i = 0, n = string.length - value.length; i <= n; i++) { if (startsWithIgnoringCase(string, value, i)) { @@ -32042,7 +27180,6 @@ var ts; } return -1; } - // Assumes 'value' is already lowercase. function startsWithIgnoringCase(string, value, start) { for (var i = 0, n = value.length; i < n; i++) { var ch1 = toLowerCase(string.charCodeAt(i + start)); @@ -32054,23 +27191,19 @@ var ts; return true; } function toLowerCase(ch) { - // Fast convert for the ascii range. - if (ch >= 65 /* A */ && ch <= 90 /* Z */) { - return 97 /* a */ + (ch - 65 /* A */); + if (ch >= 65 && ch <= 90) { + return 97 + (ch - 65); } - if (ch < 127 /* maxAsciiCharacter */) { + if (ch < 127) { return ch; } - // TODO: find a way to compute this for any unicode characters in a - // non-allocating manner. return String.fromCharCode(ch).toLowerCase().charCodeAt(0); } function isDigit(ch) { - // TODO(cyrusn): Find a way to support this for unicode digits. - return ch >= 48 /* _0 */ && ch <= 57 /* _9 */; + return ch >= 48 && ch <= 57; } function isWordChar(ch) { - return isUpperCaseLetter(ch) || isLowerCaseLetter(ch) || isDigit(ch) || ch === 95 /* _ */ || ch === 36 /* $ */; + return isUpperCaseLetter(ch) || isLowerCaseLetter(ch) || isDigit(ch) || ch === 95 || ch === 36; } function breakPatternIntoTextChunks(pattern) { var result = []; @@ -32104,11 +27237,11 @@ var ts; characterSpans: breakIntoCharacterSpans(text) }; } - /* @internal */ function breakIntoCharacterSpans(identifier) { + function breakIntoCharacterSpans(identifier) { return breakIntoSpans(identifier, false); } ts.breakIntoCharacterSpans = breakIntoCharacterSpans; - /* @internal */ function breakIntoWordSpans(identifier) { + function breakIntoWordSpans(identifier) { return breakIntoSpans(identifier, true); } ts.breakIntoWordSpans = breakIntoWordSpans; @@ -32138,29 +27271,29 @@ var ts; } function charIsPunctuation(ch) { switch (ch) { - case 33 /* exclamation */: - case 34 /* doubleQuote */: - case 35 /* hash */: - case 37 /* percent */: - case 38 /* ampersand */: - case 39 /* singleQuote */: - case 40 /* openParen */: - case 41 /* closeParen */: - case 42 /* asterisk */: - case 44 /* comma */: - case 45 /* minus */: - case 46 /* dot */: - case 47 /* slash */: - case 58 /* colon */: - case 59 /* semicolon */: - case 63 /* question */: - case 64 /* at */: - case 91 /* openBracket */: - case 92 /* backslash */: - case 93 /* closeBracket */: - case 95 /* _ */: - case 123 /* openBrace */: - case 125 /* closeBrace */: + case 33: + case 34: + case 35: + case 37: + case 38: + case 39: + case 40: + case 41: + case 42: + case 44: + case 45: + case 46: + case 47: + case 58: + case 59: + case 63: + case 64: + case 91: + case 92: + case 93: + case 95: + case 123: + case 125: return true; } return false; @@ -32168,8 +27301,7 @@ var ts; function isAllPunctuation(identifier, start, end) { for (var i = start; i < end; i++) { var ch = identifier.charCodeAt(i); - // We don't consider _ or $ as punctuation as there may be things with that name. - if (!charIsPunctuation(ch) || ch === 95 /* _ */ || ch === 36 /* $ */) { + if (!charIsPunctuation(ch) || ch === 95 || ch === 36) { return false; } } @@ -32177,25 +27309,11 @@ var ts; } function transitionFromUpperToLower(identifier, word, index, wordStart) { if (word) { - // Cases this supports: - // 1) IDisposable -> I, Disposable - // 2) UIElement -> UI, Element - // 3) HTMLDocument -> HTML, Document - // - // etc. if (index != wordStart && index + 1 < identifier.length) { var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); var nextIsLower = isLowerCaseLetter(identifier.charCodeAt(index + 1)); if (currentIsUpper && nextIsLower) { - // We have a transition from an upper to a lower letter here. But we only - // want to break if all the letters that preceded are uppercase. i.e. if we - // have "Foo" we don't want to break that into "F, oo". But if we have - // "IFoo" or "UIFoo", then we want to break that into "I, Foo" and "UI, - // Foo". i.e. the last uppercase letter belongs to the lowercase letters - // that follows. Note: this will make the following not split properly: - // "HELLOthere". However, these sorts of names do not show up in .Net - // programs. for (var i = wordStart; i < index; i++) { if (!isUpperCaseLetter(identifier.charCodeAt(i))) { return false; @@ -32210,19 +27328,6 @@ var ts; function transitionFromLowerToUpper(identifier, word, index) { var lastIsUpper = isUpperCaseLetter(identifier.charCodeAt(index - 1)); var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); - // See if the casing indicates we're starting a new word. Note: if we're breaking on - // words, then just seeing an upper case character isn't enough. Instead, it has to - // be uppercase and the previous character can't be uppercase. - // - // For example, breaking "AddMetadata" on words would make: Add Metadata - // - // on characters would be: A dd M etadata - // - // Break "AM" on words would be: AM - // - // on characters would be: A M - // - // We break the search string on characters. But we break the symbol name on words. var transition = word ? (currentIsUpper && !lastIsUpper) : currentIsUpper; @@ -32230,161 +27335,19 @@ var ts; } })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var SignatureHelp; (function (SignatureHelp) { - // A partially written generic type expression is not guaranteed to have the correct syntax tree. the expression could be parsed as less than/greater than expression or a comma expression - // or some other combination depending on what the user has typed so far. For the purposes of signature help we need to consider any location after "<" as a possible generic type reference. - // To do this, the method will back parse the expression starting at the position required. it will try to parse the current expression as a generic type expression, if it did succeed it - // will return the generic identifier that started the expression (e.g. "foo" in "foo(#a, b) -> The token introduces a list, and should begin a sig help session - // Case 2: - // fo#o#(a, b)# -> The token is either not associated with a list, or ends a list, so the session should end - // Case 3: - // foo(a#, #b#) -> The token is buried inside a list, and should give sig help - // Find out if 'node' is an argument, a type argument, or neither - if (node.kind === 24 /* LessThanToken */ || - node.kind === 16 /* OpenParenToken */) { - // Find the list that starts right *after* the < or ( token. - // If the user has just opened a list, consider this item 0. + if (node.kind === 24 || + node.kind === 16) { var list = getChildListThatStartsWithOpenerToken(callExpression, node, sourceFile); var isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos; ts.Debug.assert(list !== undefined); return { - kind: isTypeArgList ? 0 /* TypeArguments */ : 1 /* CallArguments */, + kind: isTypeArgList ? 0 : 1, invocation: callExpression, argumentsSpan: getApplicableSpanForArguments(list), argumentIndex: 0, argumentCount: getArgumentCount(list) }; } - // findListItemInfo can return undefined if we are not in parent's argument list - // or type argument list. This includes cases where the cursor is: - // - To the right of the closing paren, non-substitution template, or template tail. - // - Between the type arguments and the arguments (greater than token) - // - On the target of the call (parent.func) - // - On the 'new' keyword in a 'new' expression var listItemInfo = ts.findListItemInfo(node); if (listItemInfo) { var list = listItemInfo.list; @@ -32488,7 +27422,7 @@ var ts; var argumentCount = getArgumentCount(list); ts.Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, "argumentCount < argumentIndex, " + argumentCount + " < " + argumentIndex); return { - kind: isTypeArgList ? 0 /* TypeArguments */ : 1 /* CallArguments */, + kind: isTypeArgList ? 0 : 1, invocation: callExpression, argumentsSpan: getApplicableSpanForArguments(list), argumentIndex: argumentIndex, @@ -32496,27 +27430,24 @@ var ts; }; } } - else if (node.kind === 10 /* NoSubstitutionTemplateLiteral */ && node.parent.kind === 160 /* TaggedTemplateExpression */) { - // Check if we're actually inside the template; - // otherwise we'll fall out and return undefined. + else if (node.kind === 10 && node.parent.kind === 160) { if (ts.isInsideTemplateLiteral(node, position)) { return getArgumentListInfoForTemplate(node.parent, 0); } } - else if (node.kind === 11 /* TemplateHead */ && node.parent.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 11 && node.parent.parent.kind === 160) { var templateExpression = node.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172 /* TemplateExpression */); + ts.Debug.assert(templateExpression.kind === 172); var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1; return getArgumentListInfoForTemplate(tagExpression, argumentIndex); } - else if (node.parent.kind === 178 /* TemplateSpan */ && node.parent.parent.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.parent.kind === 178 && node.parent.parent.parent.kind === 160) { var templateSpan = node.parent; var templateExpression = templateSpan.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172 /* TemplateExpression */); - // If we're just after a template tail, don't show signature help. - if (node.kind === 13 /* TemplateTail */ && !ts.isInsideTemplateLiteral(node, position)) { + ts.Debug.assert(templateExpression.kind === 172); + if (node.kind === 13 && !ts.isInsideTemplateLiteral(node, position)) { return undefined; } var spanIndex = templateExpression.templateSpans.indexOf(templateSpan); @@ -32526,17 +27457,6 @@ var ts; return undefined; } function getArgumentIndex(argumentsList, node) { - // The list we got back can include commas. In the presence of errors it may - // also just have nodes without commas. For example "Foo(a b c)" will have 3 - // args without commas. We want to find what index we're at. So we count - // forward until we hit ourselves, only incrementing the index if it isn't a - // comma. - // - // Note: the subtlety around trailing commas (in getArgumentCount) does not apply - // here. That's because we're only walking forward until we hit the node we're - // on. In that case, even if we're after the trailing comma, we'll still see - // that trailing comma in the list, and we'll have generated the appropriate - // arg index. var argumentIndex = 0; var listChildren = argumentsList.getChildren(); for (var _i = 0; _i < listChildren.length; _i++) { @@ -32544,45 +27464,21 @@ var ts; if (child === node) { break; } - if (child.kind !== 23 /* CommaToken */) { + if (child.kind !== 23) { argumentIndex++; } } return argumentIndex; } function getArgumentCount(argumentsList) { - // The argument count for a list is normally the number of non-comma children it has. - // For example, if you have "Foo(a,b)" then there will be three children of the arg - // list 'a' '' 'b'. So, in this case the arg count will be 2. However, there - // is a small subtlety. If you have "Foo(a,)", then the child list will just have - // 'a' ''. So, in the case where the last child is a comma, we increase the - // arg count by one to compensate. - // - // Note: this subtlety only applies to the last comma. If you had "Foo(a,," then - // we'll have: 'a' '' '' - // That will give us 2 non-commas. We then add one for the last comma, givin us an - // arg count of 3. var listChildren = argumentsList.getChildren(); - var argumentCount = ts.countWhere(listChildren, function (arg) { return arg.kind !== 23 /* CommaToken */; }); - if (listChildren.length > 0 && ts.lastOrUndefined(listChildren).kind === 23 /* CommaToken */) { + var argumentCount = ts.countWhere(listChildren, function (arg) { return arg.kind !== 23; }); + if (listChildren.length > 0 && ts.lastOrUndefined(listChildren).kind === 23) { argumentCount++; } return argumentCount; } - // spanIndex is either the index for a given template span. - // This does not give appropriate results for a NoSubstitutionTemplateLiteral function getArgumentIndexForTemplatePiece(spanIndex, node) { - // Because the TemplateStringsArray is the first argument, we have to offset each substitution expression by 1. - // There are three cases we can encounter: - // 1. We are precisely in the template literal (argIndex = 0). - // 2. We are in or to the right of the substitution expression (argIndex = spanIndex + 1). - // 3. We are directly to the right of the template literal, but because we look for the token on the left, - // not enough to put us in the substitution expression; we should consider ourselves part of - // the *next* span's expression by offsetting the index (argIndex = (spanIndex + 1) + 1). - // - // Example: f `# abcd $#{# 1 + 1# }# efghi ${ #"#hello"# } # ` - // ^ ^ ^ ^ ^ ^ ^ ^ ^ - // Case: 1 1 3 2 1 3 2 2 1 ts.Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node."); if (ts.isTemplateLiteralKind(node.kind)) { if (ts.isInsideTemplateLiteral(node, position)) { @@ -32593,13 +27489,12 @@ var ts; return spanIndex + 1; } function getArgumentListInfoForTemplate(tagExpression, argumentIndex) { - // argumentCount is either 1 or (numSpans + 1) to account for the template strings array argument. - var argumentCount = tagExpression.template.kind === 10 /* NoSubstitutionTemplateLiteral */ + var argumentCount = tagExpression.template.kind === 10 ? 1 : tagExpression.template.templateSpans.length + 1; ts.Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, "argumentCount < argumentIndex, " + argumentCount + " < " + argumentIndex); return { - kind: 2 /* TaggedTemplateArguments */, + kind: 2, invocation: tagExpression, argumentsSpan: getApplicableSpanForTaggedTemplate(tagExpression), argumentIndex: argumentIndex, @@ -32607,14 +27502,6 @@ var ts; }; } function getApplicableSpanForArguments(argumentsList) { - // We use full start and skip trivia on the end because we want to include trivia on - // both sides. For example, - // - // foo( /*comment */ a, b, c /*comment*/ ) - // | | - // - // The applicable span is from the first bar to the second bar (inclusive, - // but not including parentheses) var applicableSpanStart = argumentsList.getFullStart(); var applicableSpanEnd = ts.skipTrivia(sourceFile.text, argumentsList.getEnd(), false); return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); @@ -32623,16 +27510,7 @@ var ts; var template = taggedTemplate.template; var applicableSpanStart = template.getStart(); var applicableSpanEnd = template.getEnd(); - // We need to adjust the end position for the case where the template does not have a tail. - // Otherwise, we will not show signature help past the expression. - // For example, - // - // ` ${ 1 + 1 foo(10) - // | | - // - // This is because a Missing node has no width. However, what we actually want is to include trivia - // leading up to the next token in case the user is about to type in a TemplateMiddle or TemplateTail. - if (template.kind === 172 /* TemplateExpression */) { + if (template.kind === 172) { var lastSpan = ts.lastOrUndefined(template.templateSpans); if (lastSpan.literal.getFullWidth() === 0) { applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, false); @@ -32641,12 +27519,10 @@ var ts; return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); } function getContainingArgumentInfo(node) { - for (var n = node; n.kind !== 228 /* SourceFile */; n = n.parent) { + for (var n = node; n.kind !== 228; n = n.parent) { if (ts.isFunctionBlock(n)) { return undefined; } - // If the node is not a subspan of its parent, this is a big problem. - // There have been crashes that might be caused by this violation. if (n.pos < n.parent.pos || n.end > n.parent.end) { ts.Debug.fail("Node of kind " + n.kind + " is not a subspan of its parent of kind " + n.parent.kind); } @@ -32663,14 +27539,6 @@ var ts; ts.Debug.assert(indexOfOpenerToken >= 0 && children.length > indexOfOpenerToken + 1); return children[indexOfOpenerToken + 1]; } - /** - * The selectedItemIndex could be negative for several reasons. - * 1. There are too many arguments for all of the overloads - * 2. None of the overloads were type compatible - * The solution here is to try to pick the best overload by picking - * either the first one that has an appropriate number of parameters, - * or the one with the most parameters. - */ function selectBestInvalidOverloadIndex(candidates, argumentCount) { var maxParamsSignatureIndex = -1; var maxParams = -1; @@ -32688,7 +27556,7 @@ var ts; } function createSignatureHelpItems(candidates, bestSignature, argumentListInfo) { var applicableSpan = argumentListInfo.argumentsSpan; - var isTypeParameterList = argumentListInfo.kind === 0 /* TypeArguments */; + var isTypeParameterList = argumentListInfo.kind === 0; var invocation = argumentListInfo.invocation; var callTarget = ts.getInvokedExpression(invocation); var callTargetSymbol = typeChecker.getSymbolAtLocation(callTarget); @@ -32701,10 +27569,10 @@ var ts; prefixDisplayParts.push.apply(prefixDisplayParts, callTargetDisplayParts); } if (isTypeParameterList) { - prefixDisplayParts.push(ts.punctuationPart(24 /* LessThanToken */)); + prefixDisplayParts.push(ts.punctuationPart(24)); var typeParameters = candidateSignature.typeParameters; signatureHelpParameters = typeParameters && typeParameters.length > 0 ? ts.map(typeParameters, createSignatureHelpParameterForTypeParameter) : emptyArray; - suffixDisplayParts.push(ts.punctuationPart(25 /* GreaterThanToken */)); + suffixDisplayParts.push(ts.punctuationPart(25)); var parameterParts = ts.mapToDisplayParts(function (writer) { return typeChecker.getSymbolDisplayBuilder().buildDisplayForParametersAndDelimiters(candidateSignature.parameters, writer, invocation); }); @@ -32715,10 +27583,10 @@ var ts; return typeChecker.getSymbolDisplayBuilder().buildDisplayForTypeParametersAndDelimiters(candidateSignature.typeParameters, writer, invocation); }); prefixDisplayParts.push.apply(prefixDisplayParts, typeParameterParts); - prefixDisplayParts.push(ts.punctuationPart(16 /* OpenParenToken */)); + prefixDisplayParts.push(ts.punctuationPart(16)); var parameters = candidateSignature.parameters; signatureHelpParameters = parameters.length > 0 ? ts.map(parameters, createSignatureHelpParameterForParameter) : emptyArray; - suffixDisplayParts.push(ts.punctuationPart(17 /* CloseParenToken */)); + suffixDisplayParts.push(ts.punctuationPart(17)); } var returnTypeParts = ts.mapToDisplayParts(function (writer) { return typeChecker.getSymbolDisplayBuilder().buildReturnTypeDisplay(candidateSignature, writer, invocation); @@ -32728,13 +27596,12 @@ var ts; isVariadic: candidateSignature.hasRestParameter, prefixDisplayParts: prefixDisplayParts, suffixDisplayParts: suffixDisplayParts, - separatorDisplayParts: [ts.punctuationPart(23 /* CommaToken */), ts.spacePart()], + separatorDisplayParts: [ts.punctuationPart(23), ts.spacePart()], parameters: signatureHelpParameters, documentation: candidateSignature.getDocumentationComment() }; }); var argumentIndex = argumentListInfo.argumentIndex; - // argumentCount is the *apparent* number of arguments. var argumentCount = argumentListInfo.argumentCount; var selectedItemIndex = candidates.indexOf(bestSignature); if (selectedItemIndex < 0) { @@ -32776,8 +27643,6 @@ var ts; SignatureHelp.getSignatureHelpItems = getSignatureHelpItems; })(SignatureHelp = ts.SignatureHelp || (ts.SignatureHelp = {})); })(ts || (ts = {})); -// These utilities are common to multiple language service features. -/* @internal */ var ts; (function (ts) { function getEndLinePosition(line, sourceFile) { @@ -32785,19 +27650,12 @@ var ts; var lineStarts = sourceFile.getLineStarts(); var lineIndex = line; if (lineIndex + 1 === lineStarts.length) { - // last line - return EOF return sourceFile.text.length - 1; } else { - // current line start var start = lineStarts[lineIndex]; - // take the start position of the next line -1 = it should be some line break var pos = lineStarts[lineIndex + 1] - 1; ts.Debug.assert(ts.isLineBreak(sourceFile.text.charCodeAt(pos))); - // walk backwards skipping line breaks, stop the the beginning of current line. - // i.e: - // - // $ <- end of line for this position should match the start position while (start <= pos && ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { pos--; } @@ -32842,124 +27700,115 @@ var ts; return false; } switch (n.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 155 /* ObjectLiteralExpression */: - case 151 /* ObjectBindingPattern */: - case 146 /* TypeLiteral */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 208 /* CaseBlock */: - return nodeEndsWith(n, 15 /* CloseBraceToken */, sourceFile); - case 224 /* CatchClause */: + case 202: + case 203: + case 205: + case 155: + case 151: + case 146: + case 180: + case 207: + case 208: + return nodeEndsWith(n, 15, sourceFile); + case 224: return isCompletedNode(n.block, sourceFile); - case 159 /* NewExpression */: + case 159: if (!n.arguments) { return true; } - // fall through - case 158 /* CallExpression */: - case 162 /* ParenthesizedExpression */: - case 150 /* ParenthesizedType */: - return nodeEndsWith(n, 17 /* CloseParenToken */, sourceFile); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 158: + case 162: + case 150: + return nodeEndsWith(n, 17, sourceFile); + case 143: + case 144: return isCompletedNode(n.type, sourceFile); - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 164 /* ArrowFunction */: + case 136: + case 137: + case 138: + case 201: + case 163: + case 135: + case 134: + case 140: + case 139: + case 164: if (n.body) { return isCompletedNode(n.body, sourceFile); } if (n.type) { return isCompletedNode(n.type, sourceFile); } - // Even though type parameters can be unclosed, we can get away with - // having at least a closing paren. - return hasChildOfKind(n, 17 /* CloseParenToken */, sourceFile); - case 206 /* ModuleDeclaration */: + return hasChildOfKind(n, 17, sourceFile); + case 206: return n.body && isCompletedNode(n.body, sourceFile); - case 184 /* IfStatement */: + case 184: if (n.elseStatement) { return isCompletedNode(n.elseStatement, sourceFile); } return isCompletedNode(n.thenStatement, sourceFile); - case 183 /* ExpressionStatement */: + case 183: return isCompletedNode(n.expression, sourceFile); - case 154 /* ArrayLiteralExpression */: - case 152 /* ArrayBindingPattern */: - case 157 /* ElementAccessExpression */: - case 128 /* ComputedPropertyName */: - case 148 /* TupleType */: - return nodeEndsWith(n, 19 /* CloseBracketToken */, sourceFile); - case 141 /* IndexSignature */: + case 154: + case 152: + case 157: + case 128: + case 148: + return nodeEndsWith(n, 19, sourceFile); + case 141: if (n.type) { return isCompletedNode(n.type, sourceFile); } - return hasChildOfKind(n, 19 /* CloseBracketToken */, sourceFile); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - // there is no such thing as terminator token for CaseClause/DefaultClause so for simplicitly always consider them non-completed + return hasChildOfKind(n, 19, sourceFile); + case 221: + case 222: return false; - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: + case 187: + case 188: + case 189: + case 186: return isCompletedNode(n.statement, sourceFile); - case 185 /* DoStatement */: - // rough approximation: if DoStatement has While keyword - then if node is completed is checking the presence of ')'; - var hasWhileKeyword = findChildOfKind(n, 100 /* WhileKeyword */, sourceFile); + case 185: + var hasWhileKeyword = findChildOfKind(n, 100, sourceFile); if (hasWhileKeyword) { - return nodeEndsWith(n, 17 /* CloseParenToken */, sourceFile); + return nodeEndsWith(n, 17, sourceFile); } return isCompletedNode(n.statement, sourceFile); - case 145 /* TypeQuery */: + case 145: return isCompletedNode(n.exprName, sourceFile); - case 166 /* TypeOfExpression */: - case 165 /* DeleteExpression */: - case 167 /* VoidExpression */: - case 173 /* YieldExpression */: - case 174 /* SpreadElementExpression */: + case 166: + case 165: + case 167: + case 173: + case 174: var unaryWordExpression = n; return isCompletedNode(unaryWordExpression.expression, sourceFile); - case 160 /* TaggedTemplateExpression */: + case 160: return isCompletedNode(n.template, sourceFile); - case 172 /* TemplateExpression */: + case 172: var lastSpan = ts.lastOrUndefined(n.templateSpans); return isCompletedNode(lastSpan, sourceFile); - case 178 /* TemplateSpan */: + case 178: return ts.nodeIsPresent(n.literal); - case 168 /* PrefixUnaryExpression */: + case 168: return isCompletedNode(n.operand, sourceFile); - case 170 /* BinaryExpression */: + case 170: return isCompletedNode(n.right, sourceFile); - case 171 /* ConditionalExpression */: + case 171: return isCompletedNode(n.whenFalse, sourceFile); default: return true; } } ts.isCompletedNode = isCompletedNode; - /* - * Checks if node ends with 'expectedLastToken'. - * If child at position 'length - 1' is 'SemicolonToken' it is skipped and 'expectedLastToken' is compared with child at position 'length - 2'. - */ function nodeEndsWith(n, expectedLastToken, sourceFile) { var children = n.getChildren(sourceFile); if (children.length) { - var last = children[children.length - 1]; + var last = ts.lastOrUndefined(children); if (last.kind === expectedLastToken) { return true; } - else if (last.kind === 22 /* SemicolonToken */ && children.length !== 1) { + else if (last.kind === 22 && children.length !== 1) { return children[children.length - 2].kind === expectedLastToken; } } @@ -32967,10 +27816,6 @@ var ts; } function findListItemInfo(node) { var list = findContainingList(node); - // It is possible at this point for syntaxList to be undefined, either if - // node.parent had no list child, or if none of its list children contained - // the span of node. If this happens, return undefined. The caller should - // handle this case. if (!list) { return undefined; } @@ -32991,60 +27836,43 @@ var ts; } ts.findChildOfKind = findChildOfKind; function findContainingList(node) { - // The node might be a list element (nonsynthetic) or a comma (synthetic). Either way, it will - // be parented by the container of the SyntaxList, not the SyntaxList itself. - // In order to find the list item index, we first need to locate SyntaxList itself and then search - // for the position of the relevant node (or comma). var syntaxList = ts.forEach(node.parent.getChildren(), function (c) { - // find syntax list that covers the span of the node - if (c.kind === 229 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) { + if (c.kind === 229 && c.pos <= node.pos && c.end >= node.end) { return c; } }); - // Either we didn't find an appropriate list, or the list must contain us. ts.Debug.assert(!syntaxList || ts.contains(syntaxList.getChildren(), node)); return syntaxList; } ts.findContainingList = findContainingList; - /* Gets the token whose text has range [start, end) and - * position >= start and (position < end or (position === end && token is keyword or identifier)) - */ function getTouchingWord(sourceFile, position) { return getTouchingToken(sourceFile, position, function (n) { return isWord(n.kind); }); } ts.getTouchingWord = getTouchingWord; - /* Gets the token whose text has range [start, end) and position >= start - * and (position < end or (position === end && token is keyword or identifier or numeric\string litera)) - */ function getTouchingPropertyName(sourceFile, position) { return getTouchingToken(sourceFile, position, function (n) { return isPropertyName(n.kind); }); } ts.getTouchingPropertyName = getTouchingPropertyName; - /** Returns the token if position is in [start, end) or if position === end and includeItemAtEndPosition(token) === true */ function getTouchingToken(sourceFile, position, includeItemAtEndPosition) { return getTokenAtPositionWorker(sourceFile, position, false, includeItemAtEndPosition); } ts.getTouchingToken = getTouchingToken; - /** Returns a token if position is in [start-of-leading-trivia, end) */ function getTokenAtPosition(sourceFile, position) { return getTokenAtPositionWorker(sourceFile, position, true, undefined); } ts.getTokenAtPosition = getTokenAtPosition; - /** Get the token whose text contains the position */ function getTokenAtPositionWorker(sourceFile, position, allowPositionInLeadingTrivia, includeItemAtEndPosition) { var current = sourceFile; outer: while (true) { if (isToken(current)) { - // exit early return current; } - // find the child that contains 'position' for (var i = 0, n = current.getChildCount(sourceFile); i < n; i++) { var child = current.getChildAt(i); var start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile); if (start <= position) { var end = child.getEnd(); - if (position < end || (position === end && child.kind === 1 /* EndOfFileToken */)) { + if (position < end || (position === end && child.kind === 1)) { current = child; continue outer; } @@ -33059,17 +27887,7 @@ var ts; return current; } } - /** - * The token on the left of the position is the token that strictly includes the position - * or sits to the left of the cursor if it is on a boundary. For example - * - * fo|o -> will return foo - * foo |bar -> will return foo - * - */ function findTokenOnLeftOfPosition(file, position) { - // Ideally, getTokenAtPosition should return a token. However, it is currently - // broken, so we do a check to make sure the result was indeed a token. var tokenAtPosition = getTokenAtPosition(file, position); if (isToken(tokenAtPosition) && position > tokenAtPosition.getStart(file) && position < tokenAtPosition.getEnd()) { return tokenAtPosition; @@ -33081,16 +27899,12 @@ var ts; return find(parent); function find(n) { if (isToken(n) && n.pos === previousToken.end) { - // this is token that starts at the end of previous token - return it return n; } var children = n.getChildren(); for (var _i = 0; _i < children.length; _i++) { var child = children[_i]; - var shouldDiveInChildNode = - // previous token is enclosed somewhere in the child - (child.pos <= previousToken.pos && child.end > previousToken.end) || - // previous token ends exactly at the beginning of child + var shouldDiveInChildNode = (child.pos <= previousToken.pos && child.end > previousToken.end) || (child.pos === previousToken.end); if (shouldDiveInChildNode && nodeHasTokens(child)) { return find(child); @@ -33120,28 +27934,21 @@ var ts; if (nodeHasTokens(child)) { if (position <= child.end) { if (child.getStart(sourceFile) >= position) { - // actual start of the node is past the position - previous token should be at the end of previous child var candidate = findRightmostChildNodeWithTokens(children, i); return candidate && findRightmostToken(candidate); } else { - // candidate should be in this node return find(child); } } } } - ts.Debug.assert(startNode !== undefined || n.kind === 228 /* SourceFile */); - // Here we know that none of child token nodes embrace the position, - // the only known case is when position is at the end of the file. - // Try to find the rightmost token in the file without filtering. - // Namely we are skipping the check: 'position < node.end' + ts.Debug.assert(startNode !== undefined || n.kind === 228); if (children.length) { var candidate = findRightmostChildNodeWithTokens(children, children.length); return candidate && findRightmostToken(candidate); } } - /// finds last node that is considered as candidate for search (isCandidate(node) === true) starting from 'exclusiveStartPosition' function findRightmostChildNodeWithTokens(children, exclusiveStartPosition) { for (var i = exclusiveStartPosition - 1; i >= 0; --i) { if (nodeHasTokens(children[i])) { @@ -33152,22 +27959,20 @@ var ts; } ts.findPrecedingToken = findPrecedingToken; function nodeHasTokens(n) { - // If we have a token or node that has a non-zero width, it must have tokens. - // Note, that getWidth() does not take trivia into account. return n.getWidth() !== 0; } function getNodeModifiers(node) { var flags = ts.getCombinedNodeFlags(node); var result = []; - if (flags & 32 /* Private */) + if (flags & 32) result.push(ts.ScriptElementKindModifier.privateMemberModifier); - if (flags & 64 /* Protected */) + if (flags & 64) result.push(ts.ScriptElementKindModifier.protectedMemberModifier); - if (flags & 16 /* Public */) + if (flags & 16) result.push(ts.ScriptElementKindModifier.publicMemberModifier); - if (flags & 128 /* Static */) + if (flags & 128) result.push(ts.ScriptElementKindModifier.staticModifier); - if (flags & 1 /* Export */) + if (flags & 1) result.push(ts.ScriptElementKindModifier.exportedModifier); if (ts.isInAmbientContext(node)) result.push(ts.ScriptElementKindModifier.ambientModifier); @@ -33175,32 +27980,32 @@ var ts; } ts.getNodeModifiers = getNodeModifiers; function getTypeArgumentOrTypeParameterList(node) { - if (node.kind === 142 /* TypeReference */ || node.kind === 158 /* CallExpression */) { + if (node.kind === 142 || node.kind === 158) { return node.typeArguments; } - if (ts.isFunctionLike(node) || node.kind === 202 /* ClassDeclaration */ || node.kind === 203 /* InterfaceDeclaration */) { + if (ts.isFunctionLike(node) || node.kind === 202 || node.kind === 203) { return node.typeParameters; } return undefined; } ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; function isToken(n) { - return n.kind >= 0 /* FirstToken */ && n.kind <= 126 /* LastToken */; + return n.kind >= 0 && n.kind <= 126; } ts.isToken = isToken; function isWord(kind) { - return kind === 65 /* Identifier */ || ts.isKeyword(kind); + return kind === 65 || ts.isKeyword(kind); } ts.isWord = isWord; function isPropertyName(kind) { - return kind === 8 /* StringLiteral */ || kind === 7 /* NumericLiteral */ || isWord(kind); + return kind === 8 || kind === 7 || isWord(kind); } function isComment(kind) { - return kind === 2 /* SingleLineCommentTrivia */ || kind === 3 /* MultiLineCommentTrivia */; + return kind === 2 || kind === 3; } ts.isComment = isComment; function isPunctuation(kind) { - return 14 /* FirstPunctuation */ <= kind && kind <= 64 /* LastPunctuation */; + return 14 <= kind && kind <= 64; } ts.isPunctuation = isPunctuation; function isInsideTemplateLiteral(node, position) { @@ -33210,9 +28015,9 @@ var ts; ts.isInsideTemplateLiteral = isInsideTemplateLiteral; function isAccessibilityModifier(kind) { switch (kind) { - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: + case 108: + case 106: + case 107: return true; } return false; @@ -33235,12 +28040,10 @@ var ts; } ts.compareDataObjects = compareDataObjects; })(ts || (ts = {})); -// Display-part writer helpers -/* @internal */ var ts; (function (ts) { function isFirstDeclarationOfSymbolParameter(symbol) { - return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 130 /* Parameter */; + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 130; } ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; var displayPartWriter = getDisplayPartWriter(); @@ -33295,46 +28098,46 @@ var ts; return displayPart(text, displayPartKind(symbol), symbol); function displayPartKind(symbol) { var flags = symbol.flags; - if (flags & 3 /* Variable */) { + if (flags & 3) { return isFirstDeclarationOfSymbolParameter(symbol) ? ts.SymbolDisplayPartKind.parameterName : ts.SymbolDisplayPartKind.localName; } - else if (flags & 4 /* Property */) { + else if (flags & 4) { return ts.SymbolDisplayPartKind.propertyName; } - else if (flags & 32768 /* GetAccessor */) { + else if (flags & 32768) { return ts.SymbolDisplayPartKind.propertyName; } - else if (flags & 65536 /* SetAccessor */) { + else if (flags & 65536) { return ts.SymbolDisplayPartKind.propertyName; } - else if (flags & 8 /* EnumMember */) { + else if (flags & 8) { return ts.SymbolDisplayPartKind.enumMemberName; } - else if (flags & 16 /* Function */) { + else if (flags & 16) { return ts.SymbolDisplayPartKind.functionName; } - else if (flags & 32 /* Class */) { + else if (flags & 32) { return ts.SymbolDisplayPartKind.className; } - else if (flags & 64 /* Interface */) { + else if (flags & 64) { return ts.SymbolDisplayPartKind.interfaceName; } - else if (flags & 384 /* Enum */) { + else if (flags & 384) { return ts.SymbolDisplayPartKind.enumName; } - else if (flags & 1536 /* Module */) { + else if (flags & 1536) { return ts.SymbolDisplayPartKind.moduleName; } - else if (flags & 8192 /* Method */) { + else if (flags & 8192) { return ts.SymbolDisplayPartKind.methodName; } - else if (flags & 262144 /* TypeParameter */) { + else if (flags & 262144) { return ts.SymbolDisplayPartKind.typeParameterName; } - else if (flags & 524288 /* TypeAlias */) { + else if (flags & 524288) { return ts.SymbolDisplayPartKind.aliasName; } - else if (flags & 8388608 /* Alias */) { + else if (flags & 8388608) { return ts.SymbolDisplayPartKind.aliasName; } return ts.SymbolDisplayPartKind.text; @@ -33411,19 +28214,11 @@ var ts; })(ts || (ts = {})); /// /// -/* @internal */ var ts; (function (ts) { var formatting; (function (formatting) { - var scanner = ts.createScanner(2 /* Latest */, false); - var ScanAction; - (function (ScanAction) { - ScanAction[ScanAction["Scan"] = 0] = "Scan"; - ScanAction[ScanAction["RescanGreaterThanToken"] = 1] = "RescanGreaterThanToken"; - ScanAction[ScanAction["RescanSlashToken"] = 2] = "RescanSlashToken"; - ScanAction[ScanAction["RescanTemplateToken"] = 3] = "RescanTemplateToken"; - })(ScanAction || (ScanAction = {})); + var scanner = ts.createScanner(2, false); function getFormattingScanner(sourceFile, startPos, endPos) { scanner.setText(sourceFile.text); scanner.setTextPos(startPos); @@ -33449,7 +28244,7 @@ var ts; if (isStarted) { if (trailingTrivia) { ts.Debug.assert(trailingTrivia.length !== 0); - wasNewLine = trailingTrivia[trailingTrivia.length - 1].kind === 4 /* NewLineTrivia */; + wasNewLine = ts.lastOrUndefined(trailingTrivia).kind === 4; } else { wasNewLine = false; @@ -33462,13 +28257,11 @@ var ts; } var t; var pos = scanner.getStartPos(); - // Read leading trivia and token while (pos < endPos) { var t_2 = scanner.getToken(); if (!ts.isTrivia(t_2)) { break; } - // consume leading trivia scanner.scan(); var item = { pos: pos, @@ -33486,83 +28279,72 @@ var ts; function shouldRescanGreaterThanToken(node) { if (node) { switch (node.kind) { - case 27 /* GreaterThanEqualsToken */: - case 60 /* GreaterThanGreaterThanEqualsToken */: - case 61 /* GreaterThanGreaterThanGreaterThanEqualsToken */: - case 42 /* GreaterThanGreaterThanGreaterThanToken */: - case 41 /* GreaterThanGreaterThanToken */: + case 27: + case 60: + case 61: + case 42: + case 41: return true; } } return false; } function shouldRescanSlashToken(container) { - return container.kind === 9 /* RegularExpressionLiteral */; + return container.kind === 9; } function shouldRescanTemplateToken(container) { - return container.kind === 12 /* TemplateMiddle */ || - container.kind === 13 /* TemplateTail */; + return container.kind === 12 || + container.kind === 13; } function startsWithSlashToken(t) { - return t === 36 /* SlashToken */ || t === 57 /* SlashEqualsToken */; + return t === 36 || t === 57; } function readTokenInfo(n) { if (!isOnToken()) { - // scanner is not on the token (either advance was not called yet or scanner is already past the end position) return { leadingTrivia: leadingTrivia, trailingTrivia: undefined, token: undefined }; } - // normally scanner returns the smallest available token - // check the kind of context node to determine if scanner should have more greedy behavior and consume more text. var expectedScanAction = shouldRescanGreaterThanToken(n) - ? 1 /* RescanGreaterThanToken */ + ? 1 : shouldRescanSlashToken(n) - ? 2 /* RescanSlashToken */ + ? 2 : shouldRescanTemplateToken(n) - ? 3 /* RescanTemplateToken */ - : 0 /* Scan */; + ? 3 + : 0; if (lastTokenInfo && expectedScanAction === lastScanAction) { - // readTokenInfo was called before with the same expected scan action. - // No need to re-scan text, return existing 'lastTokenInfo' - // it is ok to call fixTokenKind here since it does not affect - // what portion of text is consumed. In opposize rescanning can change it, - // i.e. for '>=' when originally scanner eats just one character - // and rescanning forces it to consume more. return fixTokenKind(lastTokenInfo, n); } if (scanner.getStartPos() !== savedPos) { ts.Debug.assert(lastTokenInfo !== undefined); - // readTokenInfo was called before but scan action differs - rescan text scanner.setTextPos(savedPos); scanner.scan(); } var currentToken = scanner.getToken(); - if (expectedScanAction === 1 /* RescanGreaterThanToken */ && currentToken === 25 /* GreaterThanToken */) { + if (expectedScanAction === 1 && currentToken === 25) { currentToken = scanner.reScanGreaterToken(); ts.Debug.assert(n.kind === currentToken); - lastScanAction = 1 /* RescanGreaterThanToken */; + lastScanAction = 1; } - else if (expectedScanAction === 2 /* RescanSlashToken */ && startsWithSlashToken(currentToken)) { + else if (expectedScanAction === 2 && startsWithSlashToken(currentToken)) { currentToken = scanner.reScanSlashToken(); ts.Debug.assert(n.kind === currentToken); - lastScanAction = 2 /* RescanSlashToken */; + lastScanAction = 2; } - else if (expectedScanAction === 3 /* RescanTemplateToken */ && currentToken === 15 /* CloseBraceToken */) { + else if (expectedScanAction === 3 && currentToken === 15) { currentToken = scanner.reScanTemplateToken(); - lastScanAction = 3 /* RescanTemplateToken */; + lastScanAction = 3; } else { - lastScanAction = 0 /* Scan */; + lastScanAction = 0; } var token = { pos: scanner.getStartPos(), end: scanner.getTextPos(), kind: currentToken }; - // consume trailing trivia if (trailingTrivia) { trailingTrivia = undefined; } @@ -33580,8 +28362,7 @@ var ts; trailingTrivia = []; } trailingTrivia.push(trivia); - if (currentToken === 4 /* NewLineTrivia */) { - // move past new line + if (currentToken === 4) { scanner.scan(); break; } @@ -33596,12 +28377,8 @@ var ts; function isOnToken() { var current = (lastTokenInfo && lastTokenInfo.token.kind) || scanner.getToken(); var startPos = (lastTokenInfo && lastTokenInfo.token.pos) || scanner.getStartPos(); - return startPos < endPos && current !== 1 /* EndOfFileToken */ && !ts.isTrivia(current); + return startPos < endPos && current !== 1 && !ts.isTrivia(current); } - // when containing node in the tree is token - // but its kind differs from the kind that was returned by the scanner, - // then kind needs to be fixed. This might happen in cases - // when parser interprets token differently, i.e keyword treated as identifier function fixTokenKind(tokenInfo, container) { if (ts.isToken(container) && tokenInfo.token.kind !== container.kind) { tokenInfo.token.kind = container.kind; @@ -33613,7 +28390,6 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -33634,7 +28410,6 @@ var ts; this.nextTokenSpan = nextRange; this.nextTokenParent = nextTokenParent; this.contextNode = commonParent; - // drop cached results this.contextNodeAllOnSameLine = undefined; this.nextNodeAllOnSameLine = undefined; this.tokensAreOnSameLine = undefined; @@ -33679,8 +28454,8 @@ var ts; return startLine == endLine; }; FormattingContext.prototype.BlockIsOnOneLine = function (node) { - var openBrace = ts.findChildOfKind(node, 14 /* OpenBraceToken */, this.sourceFile); - var closeBrace = ts.findChildOfKind(node, 15 /* CloseBraceToken */, this.sourceFile); + var openBrace = ts.findChildOfKind(node, 14, this.sourceFile); + var closeBrace = ts.findChildOfKind(node, 15, this.sourceFile); if (openBrace && closeBrace) { var startLine = this.sourceFile.getLineAndCharacterOfPosition(openBrace.getEnd()).line; var endLine = this.sourceFile.getLineAndCharacterOfPosition(closeBrace.getStart(this.sourceFile)).line; @@ -33694,30 +28469,14 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ -var ts; -(function (ts) { - var formatting; - (function (formatting) { - (function (FormattingRequestKind) { - FormattingRequestKind[FormattingRequestKind["FormatDocument"] = 0] = "FormatDocument"; - FormattingRequestKind[FormattingRequestKind["FormatSelection"] = 1] = "FormatSelection"; - FormattingRequestKind[FormattingRequestKind["FormatOnEnter"] = 2] = "FormatOnEnter"; - FormattingRequestKind[FormattingRequestKind["FormatOnSemicolon"] = 3] = "FormatOnSemicolon"; - FormattingRequestKind[FormattingRequestKind["FormatOnClosingCurlyBrace"] = 4] = "FormatOnClosingCurlyBrace"; - })(formatting.FormattingRequestKind || (formatting.FormattingRequestKind = {})); - var FormattingRequestKind = formatting.FormattingRequestKind; - })(formatting = ts.formatting || (ts.formatting = {})); -})(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; (function (formatting) { var Rule = (function () { function Rule(Descriptor, Operation, Flag) { - if (Flag === void 0) { Flag = 0 /* None */; } + if (Flag === void 0) { Flag = 0; } this.Descriptor = Descriptor; this.Operation = Operation; this.Flag = Flag; @@ -33733,22 +28492,7 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ -var ts; -(function (ts) { - var formatting; - (function (formatting) { - (function (RuleAction) { - RuleAction[RuleAction["Ignore"] = 1] = "Ignore"; - RuleAction[RuleAction["Space"] = 2] = "Space"; - RuleAction[RuleAction["NewLine"] = 4] = "NewLine"; - RuleAction[RuleAction["Delete"] = 8] = "Delete"; - })(formatting.RuleAction || (formatting.RuleAction = {})); - var RuleAction = formatting.RuleAction; - })(formatting = ts.formatting || (ts.formatting = {})); -})(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -33780,20 +28524,7 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ -var ts; -(function (ts) { - var formatting; - (function (formatting) { - (function (RuleFlags) { - RuleFlags[RuleFlags["None"] = 0] = "None"; - RuleFlags[RuleFlags["CanDeleteNewLines"] = 1] = "CanDeleteNewLines"; - })(formatting.RuleFlags || (formatting.RuleFlags = {})); - var RuleFlags = formatting.RuleFlags; - })(formatting = ts.formatting || (ts.formatting = {})); -})(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -33822,7 +28553,6 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -33857,7 +28587,6 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -33867,113 +28596,77 @@ var ts; /// /// Common Rules /// - // Leave comments alone - this.IgnoreBeforeComment = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.Comments), formatting.RuleOperation.create1(1 /* Ignore */)); - this.IgnoreAfterLineComment = new formatting.Rule(formatting.RuleDescriptor.create3(2 /* SingleLineCommentTrivia */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create1(1 /* Ignore */)); - // Space after keyword but not before ; or : or ? - this.NoSpaceBeforeSemicolon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 22 /* SemicolonToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceBeforeColon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 51 /* ColonToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */)); - this.NoSpaceBeforeQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 50 /* QuestionToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */)); - this.SpaceAfterColon = new formatting.Rule(formatting.RuleDescriptor.create3(51 /* ColonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 2 /* Space */)); - this.SpaceAfterQuestionMarkInConditionalOperator = new formatting.Rule(formatting.RuleDescriptor.create3(50 /* QuestionToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsConditionalOperatorContext), 2 /* Space */)); - this.NoSpaceAfterQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create3(50 /* QuestionToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.SpaceAfterSemicolon = new formatting.Rule(formatting.RuleDescriptor.create3(22 /* SemicolonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - // Space after }. - this.SpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15 /* CloseBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsAfterCodeBlockContext), 2 /* Space */)); - // Special case for (}, else) and (}, while) since else & while tokens are not part of the tree which makes SpaceAfterCloseBrace rule not applied - this.SpaceBetweenCloseBraceAndElse = new formatting.Rule(formatting.RuleDescriptor.create1(15 /* CloseBraceToken */, 76 /* ElseKeyword */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.SpaceBetweenCloseBraceAndWhile = new formatting.Rule(formatting.RuleDescriptor.create1(15 /* CloseBraceToken */, 100 /* WhileKeyword */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.NoSpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15 /* CloseBraceToken */, formatting.Shared.TokenRange.FromTokens([17 /* CloseParenToken */, 19 /* CloseBracketToken */, 23 /* CommaToken */, 22 /* SemicolonToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // No space for indexer and dot - this.NoSpaceBeforeDot = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 20 /* DotToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceAfterDot = new formatting.Rule(formatting.RuleDescriptor.create3(20 /* DotToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceBeforeOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 18 /* OpenBracketToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceAfterOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create3(18 /* OpenBracketToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceBeforeCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 19 /* CloseBracketToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceAfterCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create3(19 /* CloseBracketToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // Place a space before open brace in a function declaration + this.IgnoreBeforeComment = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.Comments), formatting.RuleOperation.create1(1)); + this.IgnoreAfterLineComment = new formatting.Rule(formatting.RuleDescriptor.create3(2, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create1(1)); + this.NoSpaceBeforeSemicolon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeColon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 51), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceBeforeQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 50), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.SpaceAfterColon = new formatting.Rule(formatting.RuleDescriptor.create3(51, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 2)); + this.SpaceAfterQuestionMarkInConditionalOperator = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsConditionalOperatorContext), 2)); + this.NoSpaceAfterQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterSemicolon = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsAfterCodeBlockContext), 2)); + this.SpaceBetweenCloseBraceAndElse = new formatting.Rule(formatting.RuleDescriptor.create1(15, 76), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceBetweenCloseBraceAndWhile = new formatting.Rule(formatting.RuleDescriptor.create1(15, 100), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15, formatting.Shared.TokenRange.FromTokens([17, 19, 23, 22])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeDot = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 20), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterDot = new formatting.Rule(formatting.RuleDescriptor.create3(20, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 18), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create3(18, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 19), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create3(19, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.FunctionOpenBraceLeftTokenRange = formatting.Shared.TokenRange.AnyIncludingMultilineComments; - this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2 /* Space */), 1 /* CanDeleteNewLines */); - // Place a space before open brace in a TypeScript declaration that has braces as children (class, module, enum, etc) - this.TypeScriptOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 3 /* MultiLineCommentTrivia */]); - this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2 /* Space */), 1 /* CanDeleteNewLines */); - // Place a space before open brace in a control flow construct - this.ControlOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([17 /* CloseParenToken */, 3 /* MultiLineCommentTrivia */, 75 /* DoKeyword */, 96 /* TryKeyword */, 81 /* FinallyKeyword */, 76 /* ElseKeyword */]); - this.SpaceBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2 /* Space */), 1 /* CanDeleteNewLines */); - // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}. - this.SpaceAfterOpenBrace = new formatting.Rule(formatting.RuleDescriptor.create3(14 /* OpenBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2 /* Space */)); - this.SpaceBeforeCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 15 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2 /* Space */)); - this.NoSpaceBetweenEmptyBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(14 /* OpenBraceToken */, 15 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectContext), 8 /* Delete */)); - // Insert new line after { and before } in multi-line contexts. - this.NewLineAfterOpenBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create3(14 /* OpenBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4 /* NewLine */)); - // For functions and control block place } on a new line [multi-line rule] - this.NewLineBeforeCloseBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.AnyIncludingMultilineComments, 15 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4 /* NewLine */)); - // Special handling of unary operators. - // Prefix operators generally shouldn't have a space between - // them and their target unary expression. - this.NoSpaceAfterUnaryPrefixOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.UnaryPrefixOperators, formatting.Shared.TokenRange.UnaryPrefixExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */)); - this.NoSpaceAfterUnaryPreincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(38 /* PlusPlusToken */, formatting.Shared.TokenRange.UnaryPreincrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceAfterUnaryPredecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(39 /* MinusMinusToken */, formatting.Shared.TokenRange.UnaryPredecrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceBeforeUnaryPostincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostincrementExpressions, 38 /* PlusPlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceBeforeUnaryPostdecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostdecrementExpressions, 39 /* MinusMinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // More unary operator special-casing. - // DevDiv 181814: Be careful when removing leading whitespace - // around unary operators. Examples: - // 1 - -2 --X--> 1--2 - // a + ++b --X--> a+++b - this.SpaceAfterPostincrementWhenFollowedByAdd = new formatting.Rule(formatting.RuleDescriptor.create1(38 /* PlusPlusToken */, 33 /* PlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.SpaceAfterAddWhenFollowedByUnaryPlus = new formatting.Rule(formatting.RuleDescriptor.create1(33 /* PlusToken */, 33 /* PlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.SpaceAfterAddWhenFollowedByPreincrement = new formatting.Rule(formatting.RuleDescriptor.create1(33 /* PlusToken */, 38 /* PlusPlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.SpaceAfterPostdecrementWhenFollowedBySubtract = new formatting.Rule(formatting.RuleDescriptor.create1(39 /* MinusMinusToken */, 34 /* MinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.SpaceAfterSubtractWhenFollowedByUnaryMinus = new formatting.Rule(formatting.RuleDescriptor.create1(34 /* MinusToken */, 34 /* MinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.SpaceAfterSubtractWhenFollowedByPredecrement = new formatting.Rule(formatting.RuleDescriptor.create1(34 /* MinusToken */, 39 /* MinusMinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.NoSpaceBeforeComma = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 23 /* CommaToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.SpaceAfterCertainKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([98 /* VarKeyword */, 94 /* ThrowKeyword */, 88 /* NewKeyword */, 74 /* DeleteKeyword */, 90 /* ReturnKeyword */, 97 /* TypeOfKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.SpaceAfterLetConstInVariableDeclaration = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([104 /* LetKeyword */, 70 /* ConstKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsStartOfVariableDeclarationList), 2 /* Space */)); - this.NoSpaceBeforeOpenParenInFuncCall = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionCallOrNewContext, Rules.IsPreviousTokenNotComma), 8 /* Delete */)); - this.SpaceAfterFunctionInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create3(83 /* FunctionKeyword */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */)); - this.NoSpaceBeforeOpenParenInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionDeclContext), 8 /* Delete */)); - this.SpaceAfterVoidOperator = new formatting.Rule(formatting.RuleDescriptor.create3(99 /* VoidKeyword */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsVoidOpContext), 2 /* Space */)); - this.NoSpaceBetweenReturnAndSemicolon = new formatting.Rule(formatting.RuleDescriptor.create1(90 /* ReturnKeyword */, 22 /* SemicolonToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // Add a space between statements. All keywords except (do,else,case) has open/close parens after them. - // So, we have a rule to add a space for [),Any], [do,Any], [else,Any], and [case,Any] - this.SpaceBetweenStatements = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([17 /* CloseParenToken */, 75 /* DoKeyword */, 76 /* ElseKeyword */, 67 /* CaseKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotForContext), 2 /* Space */)); - // This low-pri rule takes care of "try {" and "finally {" in case the rule SpaceBeforeOpenBraceInControl didn't execute on FormatOnEnter. - this.SpaceAfterTryFinally = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([96 /* TryKeyword */, 81 /* FinallyKeyword */]), 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - // get x() {} - // set x(val) {} - this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116 /* GetKeyword */, 121 /* SetKeyword */]), 65 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */)); - // Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options. - this.SpaceBeforeBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryKeywordOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.SpaceAfterBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryKeywordOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - // TypeScript-specific higher priority rules - // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses - this.NoSpaceAfterConstructor = new formatting.Rule(formatting.RuleDescriptor.create1(114 /* ConstructorKeyword */, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // Use of module as a function call. e.g.: import m2 = module("m2"); - this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([117 /* ModuleKeyword */, 119 /* RequireKeyword */]), 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // Add a space around certain TypeScript keywords - this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69 /* ClassKeyword */, 115 /* DeclareKeyword */, 77 /* EnumKeyword */, 78 /* ExportKeyword */, 79 /* ExtendsKeyword */, 116 /* GetKeyword */, 102 /* ImplementsKeyword */, 85 /* ImportKeyword */, 103 /* InterfaceKeyword */, 117 /* ModuleKeyword */, 118 /* NamespaceKeyword */, 106 /* PrivateKeyword */, 108 /* PublicKeyword */, 121 /* SetKeyword */, 109 /* StaticKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.SpaceBeforeCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([79 /* ExtendsKeyword */, 102 /* ImplementsKeyword */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { - this.SpaceAfterModuleName = new formatting.Rule(formatting.RuleDescriptor.create1(8 /* StringLiteral */, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsModuleDeclContext), 2 /* Space */)); - // Lambda expressions - this.SpaceAfterArrow = new formatting.Rule(formatting.RuleDescriptor.create3(32 /* EqualsGreaterThanToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - // Optional parameters and let args - this.NoSpaceAfterEllipsis = new formatting.Rule(formatting.RuleDescriptor.create1(21 /* DotDotDotToken */, 65 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceAfterOptionalParameters = new formatting.Rule(formatting.RuleDescriptor.create3(50 /* QuestionToken */, formatting.Shared.TokenRange.FromTokens([17 /* CloseParenToken */, 23 /* CommaToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */)); - // generics - this.NoSpaceBeforeOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.TypeNames, 24 /* LessThanToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8 /* Delete */)); - this.NoSpaceBetweenCloseParenAndAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create1(17 /* CloseParenToken */, 24 /* LessThanToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8 /* Delete */)); - this.NoSpaceAfterOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(24 /* LessThanToken */, formatting.Shared.TokenRange.TypeNames), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8 /* Delete */)); - this.NoSpaceBeforeCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 25 /* GreaterThanToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8 /* Delete */)); - this.NoSpaceAfterCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(25 /* GreaterThanToken */, formatting.Shared.TokenRange.FromTokens([16 /* OpenParenToken */, 18 /* OpenBracketToken */, 25 /* GreaterThanToken */, 23 /* CommaToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8 /* Delete */)); - // Remove spaces in empty interface literals. e.g.: x: {} - this.NoSpaceBetweenEmptyInterfaceBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(14 /* OpenBraceToken */, 15 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectTypeContext), 8 /* Delete */)); - // decorators - this.SpaceBeforeAt = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 52 /* AtToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.NoSpaceAfterAt = new formatting.Rule(formatting.RuleDescriptor.create3(52 /* AtToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 78 /* ExportKeyword */, 73 /* DefaultKeyword */, 69 /* ClassKeyword */, 109 /* StaticKeyword */, 108 /* PublicKeyword */, 106 /* PrivateKeyword */, 107 /* ProtectedKeyword */, 116 /* GetKeyword */, 121 /* SetKeyword */, 18 /* OpenBracketToken */, 35 /* AsteriskToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2 /* Space */)); - // These rules are higher in priority than user-configurable rules. + this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.TypeScriptOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([65, 3]); + this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.ControlOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([17, 3, 75, 96, 81, 76]); + this.SpaceBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.SpaceAfterOpenBrace = new formatting.Rule(formatting.RuleDescriptor.create3(14, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2)); + this.SpaceBeforeCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2)); + this.NoSpaceBetweenEmptyBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(14, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectContext), 8)); + this.NewLineAfterOpenBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create3(14, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4)); + this.NewLineBeforeCloseBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.AnyIncludingMultilineComments, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4)); + this.NoSpaceAfterUnaryPrefixOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.UnaryPrefixOperators, formatting.Shared.TokenRange.UnaryPrefixExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceAfterUnaryPreincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(38, formatting.Shared.TokenRange.UnaryPreincrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterUnaryPredecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(39, formatting.Shared.TokenRange.UnaryPredecrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeUnaryPostincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostincrementExpressions, 38), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeUnaryPostdecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostdecrementExpressions, 39), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterPostincrementWhenFollowedByAdd = new formatting.Rule(formatting.RuleDescriptor.create1(38, 33), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterAddWhenFollowedByUnaryPlus = new formatting.Rule(formatting.RuleDescriptor.create1(33, 33), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterAddWhenFollowedByPreincrement = new formatting.Rule(formatting.RuleDescriptor.create1(33, 38), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterPostdecrementWhenFollowedBySubtract = new formatting.Rule(formatting.RuleDescriptor.create1(39, 34), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterSubtractWhenFollowedByUnaryMinus = new formatting.Rule(formatting.RuleDescriptor.create1(34, 34), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterSubtractWhenFollowedByPredecrement = new formatting.Rule(formatting.RuleDescriptor.create1(34, 39), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.NoSpaceBeforeComma = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 23), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterCertainKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([98, 94, 88, 74, 90, 97]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterLetConstInVariableDeclaration = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([104, 70]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsStartOfVariableDeclarationList), 2)); + this.NoSpaceBeforeOpenParenInFuncCall = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionCallOrNewContext, Rules.IsPreviousTokenNotComma), 8)); + this.SpaceAfterFunctionInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create3(83, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.NoSpaceBeforeOpenParenInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionDeclContext), 8)); + this.SpaceAfterVoidOperator = new formatting.Rule(formatting.RuleDescriptor.create3(99, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsVoidOpContext), 2)); + this.NoSpaceBetweenReturnAndSemicolon = new formatting.Rule(formatting.RuleDescriptor.create1(90, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceBetweenStatements = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([17, 75, 76, 67]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotForContext), 2)); + this.SpaceAfterTryFinally = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([96, 81]), 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116, 121]), 65), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.SpaceBeforeBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryKeywordOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryKeywordOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.NoSpaceAfterConstructor = new formatting.Rule(formatting.RuleDescriptor.create1(114, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([117, 119]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69, 115, 77, 78, 79, 116, 102, 85, 103, 117, 118, 106, 108, 121, 109]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceBeforeCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([79, 102])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterModuleName = new formatting.Rule(formatting.RuleDescriptor.create1(8, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsModuleDeclContext), 2)); + this.SpaceAfterArrow = new formatting.Rule(formatting.RuleDescriptor.create3(32, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceAfterEllipsis = new formatting.Rule(formatting.RuleDescriptor.create1(21, 65), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterOptionalParameters = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.FromTokens([17, 23])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceBeforeOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.TypeNames, 24), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceBetweenCloseParenAndAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create1(17, 24), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceAfterOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(24, formatting.Shared.TokenRange.TypeNames), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceBeforeCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 25), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceAfterCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(25, formatting.Shared.TokenRange.FromTokens([16, 18, 25, 23])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceBetweenEmptyInterfaceBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(14, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectTypeContext), 8)); + this.SpaceBeforeAt = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 52), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceAfterAt = new formatting.Rule(formatting.RuleDescriptor.create3(52, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65, 78, 73, 69, 109, 108, 106, 107, 116, 121, 18, 35])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2)); this.HighPriorityCommonRules = [ this.IgnoreBeforeComment, this.IgnoreAfterLineComment, @@ -33997,7 +28690,6 @@ var ts; this.NoSpaceBeforeOpenParenInFuncCall, this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator, this.SpaceAfterVoidOperator, - // TypeScript-specific rules this.NoSpaceAfterConstructor, this.NoSpaceAfterModuleImport, this.SpaceAfterCertainTypeScriptKeywords, this.SpaceBeforeCertainTypeScriptKeywords, this.SpaceAfterModuleName, @@ -34014,7 +28706,6 @@ var ts; this.NoSpaceAfterAt, this.SpaceAfterDecorator, ]; - // These rules are lower in priority than user-configurable rules. this.LowPriorityCommonRules = [ this.NoSpaceBeforeSemicolon, @@ -34026,39 +28717,26 @@ var ts; this.NoSpaceBeforeOpenParenInFuncDecl, this.SpaceBetweenStatements, this.SpaceAfterTryFinally ]; - /// - /// Rules controlled by user options - /// - // Insert space after comma delimiter - this.SpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(23 /* CommaToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.NoSpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(23 /* CommaToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // Insert space before and after binary operators - this.SpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.SpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); - this.NoSpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 8 /* Delete */)); - this.NoSpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 8 /* Delete */)); - // Insert space after keywords in control flow statements - this.SpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 2 /* Space */)); - this.NoSpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 8 /* Delete */)); - // Open Brace braces after function - //TypeScript: Function can have return types, which can be made of tons of different token kinds - this.NewLineBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeMultilineBlockContext), 4 /* NewLine */), 1 /* CanDeleteNewLines */); - // Open Brace braces after TypeScript module/class/interface - this.NewLineBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsBeforeMultilineBlockContext), 4 /* NewLine */), 1 /* CanDeleteNewLines */); - // Open Brace braces after control block - this.NewLineBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsBeforeMultilineBlockContext), 4 /* NewLine */), 1 /* CanDeleteNewLines */); - // Insert space after semicolon in for statement - this.SpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(22 /* SemicolonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), 2 /* Space */)); - this.NoSpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(22 /* SemicolonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), 8 /* Delete */)); - // Insert space after opening and before closing nonempty parenthesis - this.SpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(16 /* OpenParenToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.SpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17 /* CloseParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); - this.NoSpaceBetweenParens = new formatting.Rule(formatting.RuleDescriptor.create1(16 /* OpenParenToken */, 17 /* CloseParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(16 /* OpenParenToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.NoSpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17 /* CloseParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - // Insert space after function keyword for anonymous functions - this.SpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(83 /* FunctionKeyword */, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */)); - this.NoSpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(83 /* FunctionKeyword */, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 8 /* Delete */)); + this.SpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(23, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(23, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.NoSpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 8)); + this.NoSpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 8)); + this.SpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 2)); + this.NoSpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 8)); + this.NewLineBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeMultilineBlockContext), 4), 1); + this.NewLineBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsBeforeMultilineBlockContext), 4), 1); + this.NewLineBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsBeforeMultilineBlockContext), 4), 1); + this.SpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), 2)); + this.NoSpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), 8)); + this.SpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(16, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceBetweenParens = new formatting.Rule(formatting.RuleDescriptor.create1(16, 17), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(16, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(83, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.NoSpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(83, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 8)); } Rules.prototype.getRuleName = function (rule) { var o = this; @@ -34069,40 +28747,30 @@ var ts; } throw new Error("Unknown rule"); }; - /// - /// Contexts - /// Rules.IsForContext = function (context) { - return context.contextNode.kind === 187 /* ForStatement */; + return context.contextNode.kind === 187; }; Rules.IsNotForContext = function (context) { return !Rules.IsForContext(context); }; Rules.IsBinaryOpContext = function (context) { switch (context.contextNode.kind) { - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: + case 170: + case 171: return true; - // equals in binding elements: function foo([[x, y] = [1, 2]]) - case 153 /* BindingElement */: - // equals in type X = ... - case 204 /* TypeAliasDeclaration */: - // equal in import a = module('a'); - case 209 /* ImportEqualsDeclaration */: - // equal in let a = 0; - case 199 /* VariableDeclaration */: - // equal in p = 0; - case 130 /* Parameter */: - case 227 /* EnumMember */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - return context.currentTokenSpan.kind === 53 /* EqualsToken */ || context.nextTokenSpan.kind === 53 /* EqualsToken */; - // "in" keyword in for (let x in []) { } - case 188 /* ForInStatement */: - return context.currentTokenSpan.kind === 86 /* InKeyword */ || context.nextTokenSpan.kind === 86 /* InKeyword */; - // Technically, "of" is not a binary operator, but format it the same way as "in" - case 189 /* ForOfStatement */: - return context.currentTokenSpan.kind === 126 /* OfKeyword */ || context.nextTokenSpan.kind === 126 /* OfKeyword */; + case 153: + case 204: + case 209: + case 199: + case 130: + case 227: + case 133: + case 132: + return context.currentTokenSpan.kind === 53 || context.nextTokenSpan.kind === 53; + case 188: + return context.currentTokenSpan.kind === 86 || context.nextTokenSpan.kind === 86; + case 189: + return context.currentTokenSpan.kind === 126 || context.nextTokenSpan.kind === 126; } return false; }; @@ -34110,7 +28778,7 @@ var ts; return !Rules.IsBinaryOpContext(context); }; Rules.IsConditionalOperatorContext = function (context) { - return context.contextNode.kind === 171 /* ConditionalExpression */; + return context.contextNode.kind === 171; }; Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) { //// This check is mainly used inside SpaceBeforeOpenBraceInControl and SpaceBeforeOpenBraceInFunction. @@ -34131,7 +28799,6 @@ var ts; //// * ) and { are on differnet lines. We only need to format if the block is multiline context. So in this case we format. return context.TokensAreOnSameLine() || Rules.IsBeforeMultilineBlockContext(context); }; - // This check is done before an open brace in a control construct, a function, or a typescript block declaration Rules.IsBeforeMultilineBlockContext = function (context) { return Rules.IsBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine()); }; @@ -34147,38 +28814,31 @@ var ts; Rules.IsBeforeBlockContext = function (context) { return Rules.NodeIsBlockContext(context.nextTokenParent); }; - // IMPORTANT!!! This method must return true ONLY for nodes with open and close braces as immediate children Rules.NodeIsBlockContext = function (node) { if (Rules.NodeIsTypeScriptDeclWithBlockContext(node)) { - // This means we are in a context that looks like a block to the user, but in the grammar is actually not a node (it's a class, module, enum, object type literal, etc). return true; } switch (node.kind) { - case 180 /* Block */: - case 208 /* CaseBlock */: - case 155 /* ObjectLiteralExpression */: - case 207 /* ModuleBlock */: + case 180: + case 208: + case 155: + case 207: return true; } return false; }; Rules.IsFunctionDeclContext = function (context) { switch (context.contextNode.kind) { - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - //case SyntaxKind.MemberFunctionDeclaration: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - ///case SyntaxKind.MethodSignature: - case 139 /* CallSignature */: - case 163 /* FunctionExpression */: - case 136 /* Constructor */: - case 164 /* ArrowFunction */: - //case SyntaxKind.ConstructorDeclaration: - //case SyntaxKind.SimpleArrowFunctionExpression: - //case SyntaxKind.ParenthesizedArrowFunctionExpression: - case 203 /* InterfaceDeclaration */: + case 201: + case 135: + case 134: + case 137: + case 138: + case 139: + case 163: + case 136: + case 164: + case 203: return true; } return false; @@ -34188,61 +28848,59 @@ var ts; }; Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) { switch (node.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 146 /* TypeLiteral */: - case 206 /* ModuleDeclaration */: + case 202: + case 203: + case 205: + case 146: + case 206: return true; } return false; }; Rules.IsAfterCodeBlockContext = function (context) { switch (context.currentTokenParent.kind) { - case 202 /* ClassDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - case 180 /* Block */: - case 224 /* CatchClause */: - case 207 /* ModuleBlock */: - case 194 /* SwitchStatement */: + case 202: + case 206: + case 205: + case 180: + case 224: + case 207: + case 194: return true; } return false; }; Rules.IsControlDeclContext = function (context) { switch (context.contextNode.kind) { - case 184 /* IfStatement */: - case 194 /* SwitchStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: - case 197 /* TryStatement */: - case 185 /* DoStatement */: - case 193 /* WithStatement */: - // TODO - // case SyntaxKind.ElseClause: - case 224 /* CatchClause */: + case 184: + case 194: + case 187: + case 188: + case 189: + case 186: + case 197: + case 185: + case 193: + case 224: return true; default: return false; } }; Rules.IsObjectContext = function (context) { - return context.contextNode.kind === 155 /* ObjectLiteralExpression */; + return context.contextNode.kind === 155; }; Rules.IsFunctionCallContext = function (context) { - return context.contextNode.kind === 158 /* CallExpression */; + return context.contextNode.kind === 158; }; Rules.IsNewContext = function (context) { - return context.contextNode.kind === 159 /* NewExpression */; + return context.contextNode.kind === 159; }; Rules.IsFunctionCallOrNewContext = function (context) { return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context); }; Rules.IsPreviousTokenNotComma = function (context) { - return context.currentTokenSpan.kind !== 23 /* CommaToken */; + return context.currentTokenSpan.kind !== 23; }; Rules.IsSameLineTokenContext = function (context) { return context.TokensAreOnSameLine(); @@ -34257,38 +28915,38 @@ var ts; while (ts.isExpression(node)) { node = node.parent; } - return node.kind === 131 /* Decorator */; + return node.kind === 131; }; Rules.IsStartOfVariableDeclarationList = function (context) { - return context.currentTokenParent.kind === 200 /* VariableDeclarationList */ && + return context.currentTokenParent.kind === 200 && context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; }; Rules.IsNotFormatOnEnter = function (context) { - return context.formattingRequestKind != 2 /* FormatOnEnter */; + return context.formattingRequestKind != 2; }; Rules.IsModuleDeclContext = function (context) { - return context.contextNode.kind === 206 /* ModuleDeclaration */; + return context.contextNode.kind === 206; }; Rules.IsObjectTypeContext = function (context) { - return context.contextNode.kind === 146 /* TypeLiteral */; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration; + return context.contextNode.kind === 146; }; Rules.IsTypeArgumentOrParameter = function (token, parent) { - if (token.kind !== 24 /* LessThanToken */ && token.kind !== 25 /* GreaterThanToken */) { + if (token.kind !== 24 && token.kind !== 25) { return false; } switch (parent.kind) { - case 142 /* TypeReference */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 142: + case 202: + case 203: + case 201: + case 163: + case 164: + case 135: + case 134: + case 139: + case 140: + case 158: + case 159: return true; default: return false; @@ -34299,7 +28957,7 @@ var ts; Rules.IsTypeArgumentOrParameter(context.nextTokenSpan, context.nextTokenParent); }; Rules.IsVoidOpContext = function (context) { - return context.currentTokenSpan.kind === 99 /* VoidKeyword */ && context.currentTokenParent.kind === 167 /* VoidExpression */; + return context.currentTokenSpan.kind === 99 && context.currentTokenParent.kind === 167; }; return Rules; })(); @@ -34307,7 +28965,6 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -34323,10 +28980,9 @@ var ts; return result; }; RulesMap.prototype.Initialize = function (rules) { - this.mapRowLength = 126 /* LastToken */ + 1; - this.map = new Array(this.mapRowLength * this.mapRowLength); //new Array(this.mapRowLength * this.mapRowLength); - // This array is used only during construction of the rulesbucket in the map - var rulesBucketConstructionStateList = new Array(this.map.length); //new Array(this.map.length); + this.mapRowLength = 126 + 1; + this.map = new Array(this.mapRowLength * this.mapRowLength); + var rulesBucketConstructionStateList = new Array(this.map.length); this.FillRules(rules, rulesBucketConstructionStateList); return this.map; }; @@ -34338,7 +28994,6 @@ var ts; }; RulesMap.prototype.GetRuleBucketIndex = function (row, column) { var rulesBucketIndex = (row * this.mapRowLength) + column; - //Debug.Assert(rulesBucketIndex < this.map.Length, "Trying to access an index outside the array."); return rulesBucketIndex; }; RulesMap.prototype.FillRule = function (rule, rulesBucketConstructionStateList) { @@ -34385,21 +29040,6 @@ var ts; var RulesPosition = formatting.RulesPosition; var RulesBucketConstructionState = (function () { function RulesBucketConstructionState() { - //// The Rules list contains all the inserted rules into a rulebucket in the following order: - //// 1- Ignore rules with specific token combination - //// 2- Ignore rules with any token combination - //// 3- Context rules with specific token combination - //// 4- Context rules with any token combination - //// 5- Non-context rules with specific token combination - //// 6- Non-context rules with any token combination - //// - //// The member rulesInsertionIndexBitmap is used to describe the number of rules - //// in each sub-bucket (above) hence can be used to know the index of where to insert - //// the next rule. It's a bitmap which contains 6 different sections each is given 5 bits. - //// - //// Example: - //// In order to insert a rule to the end of sub-bucket (3), we get the index by adding - //// the values in the bitmap segments 3rd, 2nd, and 1st. this.rulesInsertionIndexBitmap = 0; } RulesBucketConstructionState.prototype.GetInsertionIndex = function (maskPosition) { @@ -34433,7 +29073,7 @@ var ts; }; RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) { var position; - if (rule.Operation.Action == 1 /* Ignore */) { + if (rule.Operation.Action == 1) { position = specificTokens ? RulesPosition.IgnoreRulesSpecific : RulesPosition.IgnoreRulesAny; @@ -34462,7 +29102,6 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -34518,7 +29157,7 @@ var ts; } TokenAllAccess.prototype.GetTokens = function () { var result = []; - for (var token = 0 /* FirstToken */; token <= 126 /* LastToken */; token++) { + for (var token = 0; token <= 126; token++) { result.push(token); } return result; @@ -34559,18 +29198,18 @@ var ts; return this.tokenAccess.toString(); }; TokenRange.Any = TokenRange.AllTokens(); - TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3 /* MultiLineCommentTrivia */])); - TokenRange.Keywords = TokenRange.FromRange(66 /* FirstKeyword */, 126 /* LastKeyword */); - TokenRange.BinaryOperators = TokenRange.FromRange(24 /* FirstBinaryOperator */, 64 /* LastBinaryOperator */); - TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86 /* InKeyword */, 87 /* InstanceOfKeyword */, 126 /* OfKeyword */]); - TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38 /* PlusPlusToken */, 39 /* MinusMinusToken */, 47 /* TildeToken */, 46 /* ExclamationToken */]); - TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7 /* NumericLiteral */, 65 /* Identifier */, 16 /* OpenParenToken */, 18 /* OpenBracketToken */, 14 /* OpenBraceToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); - TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); - TokenRange.UnaryPostincrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 17 /* CloseParenToken */, 19 /* CloseBracketToken */, 88 /* NewKeyword */]); - TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); - TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 17 /* CloseParenToken */, 19 /* CloseBracketToken */, 88 /* NewKeyword */]); - TokenRange.Comments = TokenRange.FromTokens([2 /* SingleLineCommentTrivia */, 3 /* MultiLineCommentTrivia */]); - TokenRange.TypeNames = TokenRange.FromTokens([65 /* Identifier */, 120 /* NumberKeyword */, 122 /* StringKeyword */, 113 /* BooleanKeyword */, 123 /* SymbolKeyword */, 99 /* VoidKeyword */, 112 /* AnyKeyword */]); + TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3])); + TokenRange.Keywords = TokenRange.FromRange(66, 126); + TokenRange.BinaryOperators = TokenRange.FromRange(24, 64); + TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86, 87, 126]); + TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38, 39, 47, 46]); + TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7, 65, 16, 18, 14, 93, 88]); + TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([65, 16, 93, 88]); + TokenRange.UnaryPostincrementExpressions = TokenRange.FromTokens([65, 17, 19, 88]); + TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([65, 16, 93, 88]); + TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([65, 17, 19, 88]); + TokenRange.Comments = TokenRange.FromTokens([2, 3]); + TokenRange.TypeNames = TokenRange.FromTokens([65, 120, 122, 113, 123, 99, 112]); return TokenRange; })(); Shared.TokenRange = TokenRange; @@ -34590,7 +29229,6 @@ var ts; /// /// /// -/* @internal */ var ts; (function (ts) { var formatting; @@ -34680,36 +29318,28 @@ var ts; /// /// /// -/* @internal */ var ts; (function (ts) { var formatting; (function (formatting) { - var Constants; - (function (Constants) { - Constants[Constants["Unknown"] = -1] = "Unknown"; - })(Constants || (Constants = {})); function formatOnEnter(position, sourceFile, rulesProvider, options) { var line = sourceFile.getLineAndCharacterOfPosition(position).line; if (line === 0) { return []; } - // get the span for the previous\current line var span = { - // get start position for the previous line pos: ts.getStartPositionOfLine(line - 1, sourceFile), - // get end position for the current line (end value is exclusive so add 1 to the result) end: ts.getEndLinePosition(line, sourceFile) + 1 }; - return formatSpan(span, sourceFile, options, rulesProvider, 2 /* FormatOnEnter */); + return formatSpan(span, sourceFile, options, rulesProvider, 2); } formatting.formatOnEnter = formatOnEnter; function formatOnSemicolon(position, sourceFile, rulesProvider, options) { - return formatOutermostParent(position, 22 /* SemicolonToken */, sourceFile, options, rulesProvider, 3 /* FormatOnSemicolon */); + return formatOutermostParent(position, 22, sourceFile, options, rulesProvider, 3); } formatting.formatOnSemicolon = formatOnSemicolon; function formatOnClosingCurly(position, sourceFile, rulesProvider, options) { - return formatOutermostParent(position, 15 /* CloseBraceToken */, sourceFile, options, rulesProvider, 4 /* FormatOnClosingCurlyBrace */); + return formatOutermostParent(position, 15, sourceFile, options, rulesProvider, 4); } formatting.formatOnClosingCurly = formatOnClosingCurly; function formatDocument(sourceFile, rulesProvider, options) { @@ -34717,16 +29347,15 @@ var ts; pos: 0, end: sourceFile.text.length }; - return formatSpan(span, sourceFile, options, rulesProvider, 0 /* FormatDocument */); + return formatSpan(span, sourceFile, options, rulesProvider, 0); } formatting.formatDocument = formatDocument; function formatSelection(start, end, sourceFile, rulesProvider, options) { - // format from the beginning of the line var span = { pos: ts.getLineStartPositionForPosition(start, sourceFile), end: end }; - return formatSpan(span, sourceFile, options, rulesProvider, 1 /* FormatSelection */); + return formatSpan(span, sourceFile, options, rulesProvider, 1); } formatting.formatSelection = formatSelection; function formatOutermostParent(position, expectedLastToken, sourceFile, options, rulesProvider, requestKind) { @@ -34742,24 +29371,11 @@ var ts; } function findOutermostParent(position, expectedTokenKind, sourceFile) { var precedingToken = ts.findPrecedingToken(position, sourceFile); - // when it is claimed that trigger character was typed at given position - // we verify that there is a token with a matching kind whose end is equal to position (because the character was just typed). - // If this condition is not hold - then trigger character was typed in some other context, - // i.e.in comment and thus should not trigger autoformatting if (!precedingToken || precedingToken.kind !== expectedTokenKind || position !== precedingToken.getEnd()) { return undefined; } - // walk up and search for the parent node that ends at the same position with precedingToken. - // for cases like this - // - // let x = 1; - // while (true) { - // } - // after typing close curly in while statement we want to reformat just the while statement. - // However if we just walk upwards searching for the parent that has the same end value - - // we'll end up with the whole source file. isListElement allows to stop on the list element level var current = precedingToken; while (current && current.parent && @@ -34769,26 +29385,23 @@ var ts; } return current; } - // Returns true if node is a element in some list in parent - // i.e. parent is class declaration with the list of members and node is one of members. function isListElement(parent, node) { switch (parent.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 202: + case 203: return ts.rangeContainsRange(parent.members, node); - case 206 /* ModuleDeclaration */: + case 206: var body = parent.body; - return body && body.kind === 180 /* Block */ && ts.rangeContainsRange(body.statements, node); - case 228 /* SourceFile */: - case 180 /* Block */: - case 207 /* ModuleBlock */: + return body && body.kind === 180 && ts.rangeContainsRange(body.statements, node); + case 228: + case 180: + case 207: return ts.rangeContainsRange(parent.statements, node); - case 224 /* CatchClause */: + case 224: return ts.rangeContainsRange(parent.block.statements, node); } return false; } - /** find node that fully contains given text range */ function findEnclosingNode(range, sourceFile) { return find(sourceFile); function find(n) { @@ -34802,15 +29415,10 @@ var ts; return n; } } - /** formatting is not applied to ranges that contain parse errors. - * This function will return a predicate that for a given text range will tell - * if there are any parse errors that overlap with the range. - */ function prepareRangeContainsErrorFunction(errors, originalRange) { if (!errors.length) { return rangeHasNoErrors; } - // pick only errors that fall in range var sorted = errors .filter(function (d) { return ts.rangeOverlapsWithStartEnd(originalRange, d.start, d.start + d.length); }) .sort(function (e1, e2) { return e1.start - e2.start; }); @@ -34819,20 +29427,15 @@ var ts; } var index = 0; return function (r) { - // in current implementation sequence of arguments [r1, r2...] is monotonically increasing. - // 'index' tracks the index of the most recent error that was checked. while (true) { if (index >= sorted.length) { - // all errors in the range were already checked -> no error in specified range return false; } var error = sorted[index]; if (r.end <= error.start) { - // specified range ends before the error refered by 'index' - no error in range return false; } if (ts.startEndOverlapsWithStartEnd(r.pos, r.end, error.start, error.start + error.length)) { - // specified range overlaps with error range return true; } index++; @@ -34842,11 +29445,6 @@ var ts; return false; } } - /** - * Start of the original range might fall inside the comment - scanner will not yield appropriate results - * This function will look for token that is located before the start of target range - * and return its end as start position for the scanner. - */ function getScanStartPosition(enclosingNode, originalRange, sourceFile) { var start = enclosingNode.getStart(sourceFile); if (start === originalRange.pos && enclosingNode.end === originalRange.end) { @@ -34854,37 +29452,19 @@ var ts; } var precedingToken = ts.findPrecedingToken(originalRange.pos, sourceFile); if (!precedingToken) { - // no preceding token found - start from the beginning of enclosing node return enclosingNode.pos; } - // preceding token ends after the start of original range (i.e when originaRange.pos falls in the middle of literal) - // start from the beginning of enclosingNode to handle the entire 'originalRange' if (precedingToken.end >= originalRange.pos) { return enclosingNode.pos; } return precedingToken.end; } - /* - * For cases like - * if (a || - * b ||$ - * c) {...} - * If we hit Enter at $ we want line ' b ||' to be indented. - * Formatting will be applied to the last two lines. - * Node that fully encloses these lines is binary expression 'a ||...'. - * Initial indentation for this node will be 0. - * Binary expressions don't introduce new indentation scopes, however it is possible - * that some parent node on the same line does - like if statement in this case. - * Note that we are considering parents only from the same line with initial node - - * if parent is on the different line - its delta was already contributed - * to the initial indentation. - */ function getOwnOrInheritedDelta(n, options, sourceFile) { - var previousLine = -1 /* Unknown */; - var childKind = 0 /* Unknown */; + var previousLine = -1; + var childKind = 0; while (n) { var line = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)).line; - if (previousLine !== -1 /* Unknown */ && line !== previousLine) { + if (previousLine !== -1 && line !== previousLine) { break; } if (formatting.SmartIndenter.shouldIndentChildNode(n.kind, childKind)) { @@ -34898,9 +29478,7 @@ var ts; } function formatSpan(originalRange, sourceFile, options, rulesProvider, requestKind) { var rangeContainsError = prepareRangeContainsErrorFunction(sourceFile.parseDiagnostics, originalRange); - // formatting context is used by rules provider var formattingContext = new formatting.FormattingContext(sourceFile, requestKind); - // find the smallest node that fully wraps the range and compute the initial indentation for the node var enclosingNode = findEnclosingNode(originalRange, sourceFile); var formattingScanner = formatting.getFormattingScanner(sourceFile, getScanStartPosition(enclosingNode, originalRange, sourceFile), originalRange.end); var initialIndentation = formatting.SmartIndenter.getIndentationForNode(enclosingNode, originalRange, sourceFile, options); @@ -34908,6 +29486,8 @@ var ts; var previousRange; var previousParent; var previousRangeStartLine; + var lastIndentedLine; + var indentationOnLastIndentedLine; var edits = []; formattingScanner.advance(); if (formattingScanner.isOnToken()) { @@ -34921,17 +29501,9 @@ var ts; } formattingScanner.close(); return edits; - // local functions - /** Tries to compute the indentation for a list element. - * If list element is not in range then - * function will pick its actual indentation - * so it can be pushed downstream as inherited indentation. - * If list element is in the range - its indentation will be equal - * to inherited indentation from its predecessors. - */ function tryComputeIndentationForListItem(startPos, endPos, parentStartLine, range, inheritedIndentation) { if (ts.rangeOverlapsWithStartEnd(range, startPos, endPos)) { - if (inheritedIndentation !== -1 /* Unknown */) { + if (inheritedIndentation !== -1) { return inheritedIndentation; } } @@ -34943,20 +29515,16 @@ var ts; return column; } } - return -1 /* Unknown */; + return -1; } function computeIndentation(node, startLine, inheritedIndentation, parent, parentDynamicIndentation, effectiveParentStartLine) { var indentation = inheritedIndentation; - if (indentation === -1 /* Unknown */) { + if (indentation === -1) { if (isSomeBlock(node.kind)) { - // blocks should be indented in - // - other blocks - // - source file - // - switch\default clauses if (isSomeBlock(parent.kind) || - parent.kind === 228 /* SourceFile */ || - parent.kind === 221 /* CaseClause */ || - parent.kind === 222 /* DefaultClause */) { + parent.kind === 228 || + parent.kind === 221 || + parent.kind === 222) { indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); } else { @@ -34972,12 +29540,11 @@ var ts; } } } - var delta = formatting.SmartIndenter.shouldIndentChildNode(node.kind, 0 /* Unknown */) ? options.IndentSize : 0; + var delta = formatting.SmartIndenter.shouldIndentChildNode(node.kind, 0) ? options.IndentSize : 0; if (effectiveParentStartLine === startLine) { - // if node is located on the same line with the parent - // - inherit indentation from the parent - // - push children if either parent of node itself has non-zero delta - indentation = parentDynamicIndentation.getIndentation(); + indentation = startLine === lastIndentedLine + ? indentationOnLastIndentedLine + : parentDynamicIndentation.getIndentation(); delta = Math.min(options.IndentSize, parentDynamicIndentation.getDelta() + delta); } return { @@ -34990,19 +29557,18 @@ var ts; return node.modifiers[0].kind; } switch (node.kind) { - case 202 /* ClassDeclaration */: return 69 /* ClassKeyword */; - case 203 /* InterfaceDeclaration */: return 103 /* InterfaceKeyword */; - case 201 /* FunctionDeclaration */: return 83 /* FunctionKeyword */; - case 205 /* EnumDeclaration */: return 205 /* EnumDeclaration */; - case 137 /* GetAccessor */: return 116 /* GetKeyword */; - case 138 /* SetAccessor */: return 121 /* SetKeyword */; - case 135 /* MethodDeclaration */: + case 202: return 69; + case 203: return 103; + case 201: return 83; + case 205: return 205; + case 137: return 116; + case 138: return 121; + case 135: if (node.asteriskToken) { - return 35 /* AsteriskToken */; + return 35; } - // fall-through - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 133: + case 130: return node.name.kind; } } @@ -35010,12 +29576,8 @@ var ts; return { getIndentationForComment: function (kind) { switch (kind) { - // preceding comment to the token that closes the indentation scope inherits the indentation from the scope - // .. { - // // comment - // } - case 15 /* CloseBraceToken */: - case 19 /* CloseBracketToken */: + case 15: + case 19: return indentation + delta; } return indentation; @@ -35023,22 +29585,19 @@ var ts; getIndentationForToken: function (line, kind) { if (nodeStartLine !== line && node.decorators) { if (kind === getFirstNonDecoratorTokenOfNode(node)) { - // if this token is the first token following the list of decorators, we do not need to indent return indentation; } } switch (kind) { - // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent - case 14 /* OpenBraceToken */: - case 15 /* CloseBraceToken */: - case 18 /* OpenBracketToken */: - case 19 /* CloseBracketToken */: - case 76 /* ElseKeyword */: - case 100 /* WhileKeyword */: - case 52 /* AtToken */: + case 14: + case 15: + case 18: + case 19: + case 76: + case 100: + case 52: return indentation; default: - // if token line equals to the line of containing node (this is a first token in the node) - use node indentation return nodeStartLine !== line ? indentation + delta : indentation; } }, @@ -35052,7 +29611,7 @@ var ts; else { indentation -= options.IndentSize; } - if (formatting.SmartIndenter.shouldIndentChildNode(node.kind, 0 /* Unknown */)) { + if (formatting.SmartIndenter.shouldIndentChildNode(node.kind, 0)) { delta = options.IndentSize; } else { @@ -35067,26 +29626,12 @@ var ts; return; } var nodeDynamicIndentation = getDynamicIndentation(node, nodeStartLine, indentation, delta); - // a useful observations when tracking context node - // / - // [a] - // / | \ - // [b] [c] [d] - // node 'a' is a context node for nodes 'b', 'c', 'd' - // except for the leftmost leaf token in [b] - in this case context node ('e') is located somewhere above 'a' - // this rule can be applied recursively to child nodes of 'a'. - // - // context node is set to parent node value after processing every child node - // context node is set to parent of the token after processing every token var childContextNode = contextNode; - // if there are any tokens that logically belong to node and interleave child nodes - // such tokens will be consumed in processChildNode for for the child that follows them ts.forEachChild(node, function (child) { - processChildNode(child, -1 /* Unknown */, node, nodeDynamicIndentation, nodeStartLine, undecoratedNodeStartLine, false); + processChildNode(child, -1, node, nodeDynamicIndentation, nodeStartLine, undecoratedNodeStartLine, false); }, function (nodes) { processChildNodes(nodes, node, nodeStartLine, nodeDynamicIndentation); }); - // proceed any tokens in the node that are located after child nodes while (formattingScanner.isOnToken()) { var tokenInfo = formattingScanner.readTokenInfo(node); if (tokenInfo.token.end > node.end) { @@ -35101,15 +29646,13 @@ var ts; if (child.decorators) { undecoratedChildStartLine = sourceFile.getLineAndCharacterOfPosition(ts.getNonDecoratorTokenPosOfNode(child, sourceFile)).line; } - // if child is a list item - try to get its indentation - var childIndentationAmount = -1 /* Unknown */; + var childIndentationAmount = -1; if (isListItem) { childIndentationAmount = tryComputeIndentationForListItem(childStartPos, child.end, parentStartLine, originalRange, inheritedIndentation); - if (childIndentationAmount !== -1 /* Unknown */) { + if (childIndentationAmount !== -1) { inheritedIndentation = childIndentationAmount; } } - // child node is outside the target range - do not dive inside if (!ts.rangeOverlapsWithStartEnd(originalRange, child.pos, child.end)) { return inheritedIndentation; } @@ -35117,10 +29660,8 @@ var ts; return inheritedIndentation; } while (formattingScanner.isOnToken()) { - // proceed any parent tokens that are located prior to child.getStart() var tokenInfo = formattingScanner.readTokenInfo(node); if (tokenInfo.token.end > childStartPos) { - // stop when formatting scanner advances past the beginning of the child break; } consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); @@ -35129,13 +29670,12 @@ var ts; return inheritedIndentation; } if (ts.isToken(child)) { - // if child node is a token, it does not impact indentation, proceed it using parent indentation scope rules var tokenInfo = formattingScanner.readTokenInfo(child); ts.Debug.assert(tokenInfo.token.end === child.end); consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); return inheritedIndentation; } - var effectiveParentStartLine = child.kind === 131 /* Decorator */ ? childStartLine : undecoratedParentStartLine; + var effectiveParentStartLine = child.kind === 131 ? childStartLine : undecoratedParentStartLine; var childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine); processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta); childContextNode = node; @@ -35146,41 +29686,32 @@ var ts; var listEndToken = getCloseTokenForOpenToken(listStartToken); var listDynamicIndentation = parentDynamicIndentation; var startLine = parentStartLine; - if (listStartToken !== 0 /* Unknown */) { - // introduce a new indentation scope for lists (including list start and end tokens) + if (listStartToken !== 0) { while (formattingScanner.isOnToken()) { var tokenInfo = formattingScanner.readTokenInfo(parent); if (tokenInfo.token.end > nodes.pos) { - // stop when formatting scanner moves past the beginning of node list break; } else if (tokenInfo.token.kind === listStartToken) { - // consume list start token startLine = sourceFile.getLineAndCharacterOfPosition(tokenInfo.token.pos).line; - var indentation_1 = computeIndentation(tokenInfo.token, startLine, -1 /* Unknown */, parent, parentDynamicIndentation, startLine); + var indentation_1 = computeIndentation(tokenInfo.token, startLine, -1, parent, parentDynamicIndentation, startLine); listDynamicIndentation = getDynamicIndentation(parent, parentStartLine, indentation_1.indentation, indentation_1.delta); consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation); } else { - // consume any tokens that precede the list as child elements of 'node' using its indentation scope consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation); } } } - var inheritedIndentation = -1 /* Unknown */; + var inheritedIndentation = -1; for (var _i = 0; _i < nodes.length; _i++) { var child = nodes[_i]; inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, true); } - if (listEndToken !== 0 /* Unknown */) { + if (listEndToken !== 0) { if (formattingScanner.isOnToken()) { var tokenInfo = formattingScanner.readTokenInfo(parent); - // consume the list end token only if it is still belong to the parent - // there might be the case when current token matches end token but does not considered as one - // function (x: function) <-- - // without this check close paren will be interpreted as list end token for function expression which is wrong if (tokenInfo.token.kind === listEndToken && ts.rangeContainsRange(parent, tokenInfo.token)) { - // consume list end token consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation); } } @@ -35198,11 +29729,9 @@ var ts; var tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos); if (isTokenInRange) { var rangeHasError = rangeContainsError(currentTokenInfo.token); - // save prevStartLine since processRange will overwrite this value with current ones var prevStartLine = previousRangeStartLine; lineAdded = processRange(currentTokenInfo.token, tokenStart, parent, childContextNode, dynamicIndentation); if (rangeHasError) { - // do not indent comments\token if token range overlaps with some error indentToken = false; } else { @@ -35225,30 +29754,30 @@ var ts; if (!ts.rangeContainsRange(originalRange, triviaItem)) { continue; } - var triviaStartLine = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos).line; switch (triviaItem.kind) { - case 3 /* MultiLineCommentTrivia */: + case 3: var commentIndentation = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind); indentMultilineComment(triviaItem, commentIndentation, !indentNextTokenOrTrivia); indentNextTokenOrTrivia = false; break; - case 2 /* SingleLineCommentTrivia */: + case 2: if (indentNextTokenOrTrivia) { var commentIndentation_1 = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind); insertIndentation(triviaItem.pos, commentIndentation_1, false); indentNextTokenOrTrivia = false; } break; - case 4 /* NewLineTrivia */: + case 4: indentNextTokenOrTrivia = true; break; } } } - // indent token only if is it is in target range and does not overlap with any error ranges if (isTokenInRange && !rangeContainsError(currentTokenInfo.token)) { var tokenIndentation = dynamicIndentation.getIndentationForToken(tokenStart.line, currentTokenInfo.token.kind); insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAdded); + lastIndentedLine = tokenStart.line; + indentationOnLastIndentedLine = tokenIndentation; } } formattingScanner.advance(); @@ -35269,7 +29798,6 @@ var ts; var lineAdded; if (!rangeHasError && !previousRangeHasError) { if (!previousRange) { - // trim whitespaces starting from the beginning of the span up to the current line var originalStart = sourceFile.getLineAndCharacterOfPosition(originalRange.pos); trimTrailingWhitespacesForLines(originalStart.line, rangeStart.line); } @@ -35291,33 +29819,26 @@ var ts; var lineAdded; if (rule) { applyRuleEdits(rule, previousItem, previousStartLine, currentItem, currentStartLine); - if (rule.Operation.Action & (2 /* Space */ | 8 /* Delete */) && currentStartLine !== previousStartLine) { + if (rule.Operation.Action & (2 | 8) && currentStartLine !== previousStartLine) { lineAdded = false; - // Handle the case where the next line is moved to be the end of this line. - // In this case we don't indent the next line in the next pass. if (currentParent.getStart(sourceFile) === currentItem.pos) { dynamicIndentation.recomputeIndentation(false); } } - else if (rule.Operation.Action & 4 /* NewLine */ && currentStartLine === previousStartLine) { + else if (rule.Operation.Action & 4 && currentStartLine === previousStartLine) { lineAdded = true; - // Handle the case where token2 is moved to the new line. - // In this case we indent token2 in the next pass but we set - // sameLineIndent flag to notify the indenter that the indentation is within the line. if (currentParent.getStart(sourceFile) === currentItem.pos) { dynamicIndentation.recomputeIndentation(true); } } - // We need to trim trailing whitespace between the tokens if they were on different lines, and no rule was applied to put them on the same line trimTrailingWhitespaces = - (rule.Operation.Action & (4 /* NewLine */ | 2 /* Space */)) && - rule.Flag !== 1 /* CanDeleteNewLines */; + (rule.Operation.Action & (4 | 2)) && + rule.Flag !== 1; } else { trimTrailingWhitespaces = true; } if (currentStartLine !== previousStartLine && trimTrailingWhitespaces) { - // We need to trim trailing whitespace between the tokens if they were on different lines, and no rule was applied to put them on the same line trimTrailingWhitespacesForLines(previousStartLine, currentStartLine, previousItem); } return lineAdded; @@ -35325,8 +29846,6 @@ var ts; function insertIndentation(pos, indentation, lineAdded) { var indentationString = getIndentationString(indentation, options); if (lineAdded) { - // new line is added before the token by the formatting rules - // insert indentation string at the very beginning of the token recordReplace(pos, 0, indentationString); } else { @@ -35338,13 +29857,11 @@ var ts; } } function indentMultilineComment(commentRange, indentation, firstLineIsIndented) { - // split comment in lines var startLine = sourceFile.getLineAndCharacterOfPosition(commentRange.pos).line; var endLine = sourceFile.getLineAndCharacterOfPosition(commentRange.end).line; var parts; if (startLine === endLine) { if (!firstLineIsIndented) { - // treat as single line comment insertIndentation(commentRange.pos, indentation, false); } return; @@ -35369,7 +29886,6 @@ var ts; startIndex = 1; startLine++; } - // shift all parts on the delta size var delta = indentation - nonWhitespaceColumnInFirstPart.column; for (var i = startIndex, len = parts.length; i < len; ++i, ++startLine) { var startLinePos_1 = ts.getStartPositionOfLine(startLine, sourceFile); @@ -35390,7 +29906,6 @@ var ts; for (var line = line1; line < line2; ++line) { var lineStartPosition = ts.getStartPositionOfLine(line, sourceFile); var lineEndPosition = ts.getEndLinePosition(line, sourceFile); - // do not trim whitespaces in comments if (range && ts.isComment(range.kind) && range.pos <= lineEndPosition && range.end > lineEndPosition) { continue; } @@ -35420,35 +29935,28 @@ var ts; function applyRuleEdits(rule, previousRange, previousStartLine, currentRange, currentStartLine) { var between; switch (rule.Operation.Action) { - case 1 /* Ignore */: - // no action required + case 1: return; - case 8 /* Delete */: + case 8: if (previousRange.end !== currentRange.pos) { - // delete characters starting from t1.end up to t2.pos exclusive recordDelete(previousRange.end, currentRange.pos - previousRange.end); } break; - case 4 /* NewLine */: - // exit early if we on different lines and rule cannot change number of newlines - // if line1 and line2 are on subsequent lines then no edits are required - ok to exit - // if line1 and line2 are separated with more than one newline - ok to exit since we cannot delete extra new lines - if (rule.Flag !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) { + case 4: + if (rule.Flag !== 1 && previousStartLine !== currentStartLine) { return; } - // edit should not be applied only if we have one line feed between elements var lineDelta = currentStartLine - previousStartLine; if (lineDelta !== 1) { recordReplace(previousRange.end, currentRange.pos - previousRange.end, options.NewLineCharacter); } break; - case 2 /* Space */: - // exit early if we on different lines and rule cannot change number of newlines - if (rule.Flag !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) { + case 2: + if (rule.Flag !== 1 && previousStartLine !== currentStartLine) { return; } var posDelta = currentRange.pos - previousRange.end; - if (posDelta !== 1 || sourceFile.text.charCodeAt(previousRange.end) !== 32 /* space */) { + if (posDelta !== 1 || sourceFile.text.charCodeAt(previousRange.end) !== 32) { recordReplace(previousRange.end, currentRange.pos - previousRange.end, " "); } break; @@ -35457,57 +29965,56 @@ var ts; } function isSomeBlock(kind) { switch (kind) { - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 180: + case 207: return true; } return false; } function getOpenTokenForList(node, list) { switch (node.kind) { - case 136 /* Constructor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 164 /* ArrowFunction */: + case 136: + case 201: + case 163: + case 135: + case 134: + case 164: if (node.typeParameters === list) { - return 24 /* LessThanToken */; + return 24; } else if (node.parameters === list) { - return 16 /* OpenParenToken */; + return 16; } break; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 158: + case 159: if (node.typeArguments === list) { - return 24 /* LessThanToken */; + return 24; } else if (node.arguments === list) { - return 16 /* OpenParenToken */; + return 16; } break; - case 142 /* TypeReference */: + case 142: if (node.typeArguments === list) { - return 24 /* LessThanToken */; + return 24; } } - return 0 /* Unknown */; + return 0; } function getCloseTokenForOpenToken(kind) { switch (kind) { - case 16 /* OpenParenToken */: - return 17 /* CloseParenToken */; - case 24 /* LessThanToken */: - return 25 /* GreaterThanToken */; + case 16: + return 17; + case 24: + return 25; } - return 0 /* Unknown */; + return 0; } var internedSizes; var internedTabsIndentation; var internedSpacesIndentation; function getIndentationString(indentation, options) { - // reset interned strings if FormatCodeOptions were changed var resetInternedStrings = !internedSizes || (internedSizes.tabSize !== options.TabSize || internedSizes.indentSize !== options.IndentSize); if (resetInternedStrings) { internedSizes = { tabSize: options.TabSize, indentSize: options.IndentSize }; @@ -35556,51 +30063,42 @@ var ts; })(formatting = ts.formatting || (ts.formatting = {})); })(ts || (ts = {})); /// -/* @internal */ var ts; (function (ts) { var formatting; (function (formatting) { var SmartIndenter; (function (SmartIndenter) { - var Value; - (function (Value) { - Value[Value["Unknown"] = -1] = "Unknown"; - })(Value || (Value = {})); function getIndentation(position, sourceFile, options) { if (position > sourceFile.text.length) { - return 0; // past EOF + return 0; } var precedingToken = ts.findPrecedingToken(position, sourceFile); if (!precedingToken) { return 0; } - // no indentation in string \regex\template literals - var precedingTokenIsLiteral = precedingToken.kind === 8 /* StringLiteral */ || - precedingToken.kind === 9 /* RegularExpressionLiteral */ || - precedingToken.kind === 10 /* NoSubstitutionTemplateLiteral */ || - precedingToken.kind === 11 /* TemplateHead */ || - precedingToken.kind === 12 /* TemplateMiddle */ || - precedingToken.kind === 13 /* TemplateTail */; + var precedingTokenIsLiteral = precedingToken.kind === 8 || + precedingToken.kind === 9 || + precedingToken.kind === 10 || + precedingToken.kind === 11 || + precedingToken.kind === 12 || + precedingToken.kind === 13; if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && precedingToken.end > position) { return 0; } var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; - if (precedingToken.kind === 23 /* CommaToken */ && precedingToken.parent.kind !== 170 /* BinaryExpression */) { - // previous token is comma that separates items in list - find the previous item and try to derive indentation from it + if (precedingToken.kind === 23 && precedingToken.parent.kind !== 170) { var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); - if (actualIndentation !== -1 /* Unknown */) { + if (actualIndentation !== -1) { return actualIndentation; } } - // try to find node that can contribute to indentation and includes 'position' starting from 'precedingToken' - // if such node is found - compute initial indentation for 'position' inside this node var previous; var current = precedingToken; var currentStart; var indentationDelta; while (current) { - if (ts.positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current.kind, previous ? previous.kind : 0 /* Unknown */)) { + if (ts.positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current.kind, previous ? previous.kind : 0)) { currentStart = getStartLineAndCharacterForNode(current, sourceFile); if (nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile)) { indentationDelta = 0; @@ -35610,16 +30108,14 @@ var ts; } break; } - // check if current node is a list item - if yes, take indentation from it var actualIndentation = getActualIndentationForListItem(current, sourceFile, options); - if (actualIndentation !== -1 /* Unknown */) { + if (actualIndentation !== -1) { return actualIndentation; } previous = current; current = current.parent; } if (!current) { - // no parent was found - return 0 to be indented on the level of SourceFile return 0; } return getIndentationForNodeWorker(current, currentStart, undefined, indentationDelta, sourceFile, options); @@ -35633,8 +30129,6 @@ var ts; function getIndentationForNodeWorker(current, currentStart, ignoreActualIndentationRange, indentationDelta, sourceFile, options) { var parent = current.parent; var parentStart; - // walk upwards and collect indentations for pairs of parent-child nodes - // indentation is not added if parent and child nodes start on the same line or if parent is IfStatement and child starts on the same line with 'else clause' while (parent) { var useActualIndentation = true; if (ignoreActualIndentationRange) { @@ -35642,9 +30136,8 @@ var ts; useActualIndentation = start < ignoreActualIndentationRange.pos || start > ignoreActualIndentationRange.end; } if (useActualIndentation) { - // check if current node is a list item - if yes, take indentation from it var actualIndentation = getActualIndentationForListItem(current, sourceFile, options); - if (actualIndentation !== -1 /* Unknown */) { + if (actualIndentation !== -1) { return actualIndentation + indentationDelta; } } @@ -35652,13 +30145,11 @@ var ts; var parentAndChildShareLine = parentStart.line === currentStart.line || childStartsOnTheSameLineWithElseInIfStatement(parent, current, currentStart.line, sourceFile); if (useActualIndentation) { - // try to fetch actual indentation for current node from source text var actualIndentation = getActualIndentationForNode(current, parent, currentStart, parentAndChildShareLine, sourceFile, options); - if (actualIndentation !== -1 /* Unknown */) { + if (actualIndentation !== -1) { return actualIndentation + indentationDelta; } } - // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line if (shouldIndentChildNode(parent.kind, current.kind) && !parentAndChildShareLine) { indentationDelta += options.IndentSize; } @@ -35675,31 +30166,20 @@ var ts; } return sourceFile.getLineAndCharacterOfPosition(parent.getStart(sourceFile)); } - /* - * Function returns Value.Unknown if indentation cannot be determined - */ function getActualIndentationForListItemBeforeComma(commaToken, sourceFile, options) { - // previous token is comma that separates items in list - find the previous item and try to derive indentation from it var commaItemInfo = ts.findListItemInfo(commaToken); if (commaItemInfo && commaItemInfo.listItemIndex > 0) { return deriveActualIndentationFromList(commaItemInfo.list.getChildren(), commaItemInfo.listItemIndex - 1, sourceFile, options); } else { - // handle broken code gracefully - return -1 /* Unknown */; + return -1; } } - /* - * Function returns Value.Unknown if actual indentation for node should not be used (i.e because node is nested expression) - */ function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) { - // actual indentation is used for statements\declarations if one of cases below is true: - // - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually - // - parent and child are not on the same line var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) && - (parent.kind === 228 /* SourceFile */ || !parentAndChildShareLine); + (parent.kind === 228 || !parentAndChildShareLine); if (!useActualIndentation) { - return -1 /* Unknown */; + return -1; } return findColumnForFirstNonWhitespaceCharacterInLine(currentLineAndChar, sourceFile, options); } @@ -35708,19 +30188,10 @@ var ts; if (!nextToken) { return false; } - if (nextToken.kind === 14 /* OpenBraceToken */) { - // open braces are always indented at the parent level + if (nextToken.kind === 14) { return true; } - else if (nextToken.kind === 15 /* CloseBraceToken */) { - // close braces are indented at the parent level if they are located on the same line with cursor - // this means that if new line will be added at $ position, this case will be indented - // class A { - // $ - // } - /// and this one - not - // class A { - // $} + else if (nextToken.kind === 15) { var nextTokenStartLine = getStartLineAndCharacterForNode(nextToken, sourceFile).line; return lineAtPosition === nextTokenStartLine; } @@ -35730,8 +30201,8 @@ var ts; return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); } function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { - if (parent.kind === 184 /* IfStatement */ && parent.elseStatement === child) { - var elseKeyword = ts.findChildOfKind(parent, 76 /* ElseKeyword */, sourceFile); + if (parent.kind === 184 && parent.elseStatement === child) { + var elseKeyword = ts.findChildOfKind(parent, 76, sourceFile); ts.Debug.assert(elseKeyword !== undefined); var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; return elseKeywordStartLine === childStartLine; @@ -35742,23 +30213,23 @@ var ts; function getContainingList(node, sourceFile) { if (node.parent) { switch (node.parent.kind) { - case 142 /* TypeReference */: + case 142: if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) { return node.parent.typeArguments; } break; - case 155 /* ObjectLiteralExpression */: + case 155: return node.parent.properties; - case 154 /* ArrayLiteralExpression */: + case 154: return node.parent.elements; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: { + case 201: + case 163: + case 164: + case 135: + case 134: + case 139: + case 140: { var start = node.getStart(sourceFile); if (node.parent.typeParameters && ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) { @@ -35769,8 +30240,8 @@ var ts; } break; } - case 159 /* NewExpression */: - case 158 /* CallExpression */: { + case 159: + case 158: { var start = node.getStart(sourceFile); if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) { @@ -35788,42 +30259,32 @@ var ts; } function getActualIndentationForListItem(node, sourceFile, options) { var containingList = getContainingList(node, sourceFile); - return containingList ? getActualIndentationFromList(containingList) : -1 /* Unknown */; + return containingList ? getActualIndentationFromList(containingList) : -1; function getActualIndentationFromList(list) { var index = ts.indexOf(list, node); - return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : -1 /* Unknown */; + return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : -1; } } function deriveActualIndentationFromList(list, index, sourceFile, options) { ts.Debug.assert(index >= 0 && index < list.length); var node = list[index]; - // walk toward the start of the list starting from current node and check if the line is the same for all items. - // if end line for item [i - 1] differs from the start line for item [i] - find column of the first non-whitespace character on the line of item [i] var lineAndCharacter = getStartLineAndCharacterForNode(node, sourceFile); for (var i = index - 1; i >= 0; --i) { - if (list[i].kind === 23 /* CommaToken */) { + if (list[i].kind === 23) { continue; } - // skip list items that ends on the same line with the current list element var prevEndLine = sourceFile.getLineAndCharacterOfPosition(list[i].end).line; if (prevEndLine !== lineAndCharacter.line) { return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options); } lineAndCharacter = getStartLineAndCharacterForNode(list[i], sourceFile); } - return -1 /* Unknown */; + return -1; } function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options) { var lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0); return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options); } - /* - Character is the actual index of the character since the beginning of the line. - Column - position of the character after expanding tabs to spaces - "0\t2$" - value of 'character' for '$' is 3 - value of 'column' for '$' is 6 (assuming that tab size is 4) - */ function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) { var character = 0; var column = 0; @@ -35832,7 +30293,7 @@ var ts; if (!ts.isWhiteSpace(ch)) { break; } - if (ch === 9 /* tab */) { + if (ch === 9) { column += options.TabSize + (column % options.TabSize); } else { @@ -35849,28 +30310,28 @@ var ts; SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; function nodeContentIsAlwaysIndented(kind) { switch (kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 154 /* ArrayLiteralExpression */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 155 /* ObjectLiteralExpression */: - case 146 /* TypeLiteral */: - case 148 /* TupleType */: - case 208 /* CaseBlock */: - case 222 /* DefaultClause */: - case 221 /* CaseClause */: - case 162 /* ParenthesizedExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 181 /* VariableStatement */: - case 199 /* VariableDeclaration */: - case 215 /* ExportAssignment */: - case 192 /* ReturnStatement */: - case 171 /* ConditionalExpression */: - case 152 /* ArrayBindingPattern */: - case 151 /* ObjectBindingPattern */: + case 202: + case 203: + case 205: + case 154: + case 180: + case 207: + case 155: + case 146: + case 148: + case 208: + case 222: + case 221: + case 162: + case 158: + case 159: + case 181: + case 199: + case 215: + case 192: + case 171: + case 152: + case 151: return true; } return false; @@ -35880,22 +30341,22 @@ var ts; return true; } switch (parent) { - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 184 /* IfStatement */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 164 /* ArrowFunction */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - return child !== 180 /* Block */; + case 185: + case 186: + case 188: + case 189: + case 187: + case 184: + case 201: + case 163: + case 135: + case 134: + case 139: + case 164: + case 136: + case 137: + case 138: + return child !== 180; default: return false; } @@ -35922,7 +30383,6 @@ var __extends = (this && this.__extends) || function (d, b) { /// var ts; (function (ts) { - /** The version of the language service API */ ts.servicesVersion = "0.4"; var ScriptSnapshot; (function (ScriptSnapshot) { @@ -35938,8 +30398,6 @@ var ts; return this.text.length; }; StringScriptSnapshot.prototype.getChangeRange = function (oldSnapshot) { - // Text-based snapshots do not support incremental parsing. Return undefined - // to signal that to the caller. return undefined; }; return StringScriptSnapshot; @@ -35949,7 +30407,7 @@ var ts; } ScriptSnapshot.fromString = fromString; })(ScriptSnapshot = ts.ScriptSnapshot || (ts.ScriptSnapshot = {})); - var scanner = ts.createScanner(2 /* Latest */, true); + var scanner = ts.createScanner(2, true); var emptyArray = []; function createNode(kind, pos, end, flags, parent) { var node = new (ts.getNodeConstructor(kind))(); @@ -35994,13 +30452,13 @@ var ts; while (pos < end) { var token = scanner.scan(); var textPos = scanner.getTextPos(); - nodes.push(createNode(token, pos, textPos, 1024 /* Synthetic */, this)); + nodes.push(createNode(token, pos, textPos, 1024, this)); pos = textPos; } return pos; }; NodeObject.prototype.createSyntaxList = function (nodes) { - var list = createNode(229 /* SyntaxList */, nodes.pos, nodes.end, 1024 /* Synthetic */, this); + var list = createNode(229, nodes.pos, nodes.end, 1024, this); list._children = []; var pos = nodes.pos; for (var _i = 0; _i < nodes.length; _i++) { @@ -36019,7 +30477,7 @@ var ts; NodeObject.prototype.createChildren = function (sourceFile) { var _this = this; var children; - if (this.kind >= 127 /* FirstNode */) { + if (this.kind >= 127) { scanner.setText((sourceFile || this.getSourceFile()).text); children = []; var pos = this.pos; @@ -36064,7 +30522,7 @@ var ts; var children = this.getChildren(); for (var _i = 0; _i < children.length; _i++) { var child = children[_i]; - if (child.kind < 127 /* FirstNode */) { + if (child.kind < 127) { return child; } return child.getFirstToken(sourceFile); @@ -36074,7 +30532,7 @@ var ts; var children = this.getChildren(sourceFile); for (var i = children.length - 1; i >= 0; i--) { var child = children[i]; - if (child.kind < 127 /* FirstNode */) { + if (child.kind < 127) { return child; } return child.getLastToken(sourceFile); @@ -36098,7 +30556,7 @@ var ts; }; SymbolObject.prototype.getDocumentationComment = function () { if (this.documentationComment === undefined) { - this.documentationComment = getJsDocCommentsFromDeclarations(this.declarations, this.name, !(this.flags & 4 /* Property */)); + this.documentationComment = getJsDocCommentsFromDeclarations(this.declarations, this.name, !(this.flags & 4)); } return this.documentationComment; }; @@ -36118,16 +30576,9 @@ var ts; var paramTag = "@param"; var jsDocCommentParts = []; ts.forEach(declarations, function (declaration, indexOfDeclaration) { - // Make sure we are collecting doc comment from declaration once, - // In case of union property there might be same declaration multiple times - // which only varies in type parameter - // Eg. let a: Array | Array; a.length - // The property length will have two declarations of property length coming - // from Array - Array and Array if (ts.indexOf(declarations, declaration) === indexOfDeclaration) { var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration); - // If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments - if (canUseParsedParamTagComments && declaration.kind === 130 /* Parameter */) { + if (canUseParsedParamTagComments && declaration.kind === 130) { ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedParamJsDocComment) { @@ -36135,16 +30586,13 @@ var ts; } }); } - // If this is left side of dotted module declaration, there is no doc comments associated with this node - if (declaration.kind === 206 /* ModuleDeclaration */ && declaration.body.kind === 206 /* ModuleDeclaration */) { + if (declaration.kind === 206 && declaration.body.kind === 206) { return; } - // If this is dotted module name, get the doc comments from the parent - while (declaration.kind === 206 /* ModuleDeclaration */ && declaration.parent.kind === 206 /* ModuleDeclaration */) { + while (declaration.kind === 206 && declaration.parent.kind === 206) { declaration = declaration.parent; } - // Get the cleaned js doc comment text from the declaration - ts.forEach(getJsDocCommentTextRange(declaration.kind === 199 /* VariableDeclaration */ ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + ts.forEach(getJsDocCommentTextRange(declaration.kind === 199 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedJsDocComment) { jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment); @@ -36157,7 +30605,7 @@ var ts; return ts.map(ts.getJsDocComments(node, sourceFile), function (jsDocComment) { return { pos: jsDocComment.pos + "/*".length, - end: jsDocComment.end - "*/".length // Trim off comment end indicator + end: jsDocComment.end - "*/".length }; }); } @@ -36168,7 +30616,6 @@ var ts; for (; pos < end; pos++) { var ch = sourceFile.text.charCodeAt(pos); if (!ts.isWhiteSpace(ch) || ts.isLineBreak(ch)) { - // Either found lineBreak or non whiteSpace return pos; } } @@ -36187,11 +30634,9 @@ var ts; ts.isLineBreak(sourceFile.text.charCodeAt(pos + name.length))); } function isParamTag(pos, end, sourceFile) { - // If it is @param tag return isName(pos, end, sourceFile, paramTag); } function pushDocCommentLineText(docComments, text, blankLineCount) { - // Add the empty lines in between texts while (blankLineCount--) { docComments.push(ts.textPart("")); } @@ -36204,13 +30649,10 @@ var ts; var isInParamTag = false; while (pos < end) { var docCommentTextOfLine = ""; - // First consume leading white space pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile); - // If the comment starts with '*' consume the spaces on this line - if (pos < end && sourceFile.text.charCodeAt(pos) === 42 /* asterisk */) { + if (pos < end && sourceFile.text.charCodeAt(pos) === 42) { var lineStartPos = pos + 1; pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, spacesToRemoveAfterAsterisk); - // Set the spaces to remove after asterisk as margin if not already set if (spacesToRemoveAfterAsterisk === undefined && pos < end && !ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { spacesToRemoveAfterAsterisk = pos - lineStartPos; } @@ -36218,11 +30660,9 @@ var ts; else if (spacesToRemoveAfterAsterisk === undefined) { spacesToRemoveAfterAsterisk = 0; } - // Analyse text on this line while (pos < end && !ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { var ch = sourceFile.text.charAt(pos); if (ch === "@") { - // If it is @param tag if (isParamTag(pos, end, sourceFile)) { isInParamTag = true; pos += paramTag.length; @@ -36232,21 +30672,17 @@ var ts; isInParamTag = false; } } - // Add the ch to doc text if we arent in param tag if (!isInParamTag) { docCommentTextOfLine += ch; } - // Scan next character pos++; } - // Continue with next line pos = consumeLineBreaks(pos, end, sourceFile); if (docCommentTextOfLine) { pushDocCommentLineText(docComments, docCommentTextOfLine, blankLineCount); blankLineCount = 0; } else if (!isInParamTag && docComments.length) { - // This is blank line when there is text already parsed blankLineCount++; } } @@ -36259,48 +30695,38 @@ var ts; if (isParamTag(pos, end, sourceFile)) { var blankLineCount = 0; var recordedParamTag = false; - // Consume leading spaces pos = consumeWhiteSpaces(pos + paramTag.length); if (pos >= end) { break; } - // Ignore type expression - if (sourceFile.text.charCodeAt(pos) === 123 /* openBrace */) { + if (sourceFile.text.charCodeAt(pos) === 123) { pos++; for (var curlies = 1; pos < end; pos++) { var charCode = sourceFile.text.charCodeAt(pos); - // { character means we need to find another } to match the found one - if (charCode === 123 /* openBrace */) { + if (charCode === 123) { curlies++; continue; } - // } char - if (charCode === 125 /* closeBrace */) { + if (charCode === 125) { curlies--; if (curlies === 0) { - // We do not have any more } to match the type expression is ignored completely pos++; break; } else { - // there are more { to be matched with } continue; } } - // Found start of another tag - if (charCode === 64 /* at */) { + if (charCode === 64) { break; } } - // Consume white spaces pos = consumeWhiteSpaces(pos); if (pos >= end) { break; } } - // Parameter name if (isName(pos, end, sourceFile, name)) { - // Found the parameter we are looking for consume white spaces pos = consumeWhiteSpaces(pos + name.length); if (pos >= end) { break; @@ -36309,7 +30735,6 @@ var ts; var firstLineParamHelpStringPos = pos; while (pos < end) { var ch = sourceFile.text.charCodeAt(pos); - // at line break, set this comment line text and go to next line if (ts.isLineBreak(ch)) { if (paramHelpString) { pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount); @@ -36320,30 +30745,24 @@ var ts; else if (recordedParamTag) { blankLineCount++; } - // Get the pos after cleaning start of the line setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos); continue; } - // Done scanning param help string - next tag found - if (ch === 64 /* at */) { + if (ch === 64) { break; } paramHelpString += sourceFile.text.charAt(pos); - // Go to next character pos++; } - // If there is param help text, add it top the doc comments if (paramHelpString) { pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount); } paramHelpStringMargin = undefined; } - // If this is the start of another tag, continue with the loop in seach of param tag with symbol name - if (sourceFile.text.charCodeAt(pos) === 64 /* at */) { + if (sourceFile.text.charCodeAt(pos) === 64) { continue; } } - // Next character pos++; } return paramDocComments; @@ -36354,7 +30773,6 @@ var ts; return pos; } function setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos) { - // Get the pos after consuming line breaks pos = consumeLineBreaks(pos, end, sourceFile); if (pos >= end) { return; @@ -36362,7 +30780,6 @@ var ts; if (paramHelpStringMargin === undefined) { paramHelpStringMargin = sourceFile.getLineAndCharacterOfPosition(firstLineParamHelpStringPos).character; } - // Now consume white spaces max var startOfLinePos = pos; pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile, paramHelpStringMargin); if (pos >= end) { @@ -36371,8 +30788,7 @@ var ts; var consumedSpaces = pos - startOfLinePos; if (consumedSpaces < paramHelpStringMargin) { var ch = sourceFile.text.charCodeAt(pos); - if (ch === 42 /* asterisk */) { - // Consume more spaces after asterisk + if (ch === 42) { pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, paramHelpStringMargin - consumedSpaces - 1); } } @@ -36401,16 +30817,16 @@ var ts; return this.checker.getAugmentedPropertiesOfType(this); }; TypeObject.prototype.getCallSignatures = function () { - return this.checker.getSignaturesOfType(this, 0 /* Call */); + return this.checker.getSignaturesOfType(this, 0); }; TypeObject.prototype.getConstructSignatures = function () { - return this.checker.getSignaturesOfType(this, 1 /* Construct */); + return this.checker.getSignaturesOfType(this, 1); }; TypeObject.prototype.getStringIndexType = function () { - return this.checker.getIndexTypeOfType(this, 0 /* String */); + return this.checker.getIndexTypeOfType(this, 0); }; TypeObject.prototype.getNumberIndexType = function () { - return this.checker.getIndexTypeOfType(this, 1 /* Number */); + return this.checker.getIndexTypeOfType(this, 1); }; return TypeObject; })(); @@ -36432,9 +30848,7 @@ var ts; }; SignatureObject.prototype.getDocumentationComment = function () { if (this.documentationComment === undefined) { - this.documentationComment = this.declaration ? getJsDocCommentsFromDeclarations([this.declaration], - /*name*/ undefined, - /*canUseParsedParamTagComments*/ false) : []; + this.documentationComment = this.declaration ? getJsDocCommentsFromDeclarations([this.declaration], undefined, false) : []; } return this.documentationComment; }; @@ -36483,9 +30897,9 @@ var ts; if (result_2 !== undefined) { return result_2; } - if (declaration.name.kind === 128 /* ComputedPropertyName */) { + if (declaration.name.kind === 128) { var expr = declaration.name.expression; - if (expr.kind === 156 /* PropertyAccessExpression */) { + if (expr.kind === 156) { return expr.name.text; } return getTextOfIdentifierOrLiteral(expr); @@ -36495,9 +30909,9 @@ var ts; } function getTextOfIdentifierOrLiteral(node) { if (node) { - if (node.kind === 65 /* Identifier */ || - node.kind === 8 /* StringLiteral */ || - node.kind === 7 /* NumericLiteral */) { + if (node.kind === 65 || + node.kind === 8 || + node.kind === 7) { return node.text; } } @@ -36505,18 +30919,15 @@ var ts; } function visit(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 201: + case 135: + case 134: var functionDeclaration = node; var declarationName = getDeclarationName(functionDeclaration); if (declarationName) { var declarations = getDeclarations(declarationName); var lastDeclaration = ts.lastOrUndefined(declarations); - // Check whether this declaration belongs to an "overload group". if (lastDeclaration && functionDeclaration.parent === lastDeclaration.parent && functionDeclaration.symbol === lastDeclaration.symbol) { - // Overwrite the last declaration if it was an overload - // and this one is an implementation. if (functionDeclaration.body && !lastDeclaration.body) { declarations[declarations.length - 1] = functionDeclaration; } @@ -36527,72 +30938,62 @@ var ts; ts.forEachChild(node, visit); } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 218 /* ExportSpecifier */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 146 /* TypeLiteral */: + case 202: + case 203: + case 204: + case 205: + case 206: + case 209: + case 218: + case 214: + case 209: + case 211: + case 212: + case 137: + case 138: + case 146: addDeclaration(node); - // fall through - case 136 /* Constructor */: - case 181 /* VariableStatement */: - case 200 /* VariableDeclarationList */: - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 207 /* ModuleBlock */: + case 136: + case 181: + case 200: + case 151: + case 152: + case 207: ts.forEachChild(node, visit); break; - case 180 /* Block */: + case 180: if (ts.isFunctionBlock(node)) { ts.forEachChild(node, visit); } break; - case 130 /* Parameter */: - // Only consider properties defined as constructor parameters - if (!(node.flags & 112 /* AccessibilityModifier */)) { + case 130: + if (!(node.flags & 112)) { break; } - // fall through - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 199: + case 153: if (ts.isBindingPattern(node.name)) { ts.forEachChild(node.name, visit); break; } - case 227 /* EnumMember */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 227: + case 133: + case 132: addDeclaration(node); break; - case 216 /* ExportDeclaration */: - // Handle named exports case e.g.: - // export {a, b as B} from "mod"; + case 216: if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210 /* ImportDeclaration */: + case 210: var importClause = node.importClause; if (importClause) { - // Handle default import case e.g.: - // import d from "mod"; if (importClause.name) { addDeclaration(importClause); } - // Handle named bindings in imports e.g.: - // import * as NS from "mod"; - // import {a, b as B} from "mod"; if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 212) { addDeclaration(importClause.namedBindings); } else { @@ -36644,22 +31045,6 @@ var ts; SymbolDisplayPartKind[SymbolDisplayPartKind["regularExpressionLiteral"] = 21] = "regularExpressionLiteral"; })(ts.SymbolDisplayPartKind || (ts.SymbolDisplayPartKind = {})); var SymbolDisplayPartKind = ts.SymbolDisplayPartKind; - (function (OutputFileType) { - OutputFileType[OutputFileType["JavaScript"] = 0] = "JavaScript"; - OutputFileType[OutputFileType["SourceMap"] = 1] = "SourceMap"; - OutputFileType[OutputFileType["Declaration"] = 2] = "Declaration"; - })(ts.OutputFileType || (ts.OutputFileType = {})); - var OutputFileType = ts.OutputFileType; - (function (EndOfLineState) { - EndOfLineState[EndOfLineState["None"] = 0] = "None"; - EndOfLineState[EndOfLineState["InMultiLineCommentTrivia"] = 1] = "InMultiLineCommentTrivia"; - EndOfLineState[EndOfLineState["InSingleQuoteStringLiteral"] = 2] = "InSingleQuoteStringLiteral"; - EndOfLineState[EndOfLineState["InDoubleQuoteStringLiteral"] = 3] = "InDoubleQuoteStringLiteral"; - EndOfLineState[EndOfLineState["InTemplateHeadOrNoSubstitutionTemplate"] = 4] = "InTemplateHeadOrNoSubstitutionTemplate"; - EndOfLineState[EndOfLineState["InTemplateMiddleOrTail"] = 5] = "InTemplateMiddleOrTail"; - EndOfLineState[EndOfLineState["InTemplateSubstitutionPosition"] = 6] = "InTemplateSubstitutionPosition"; - })(ts.EndOfLineState || (ts.EndOfLineState = {})); - var EndOfLineState = ts.EndOfLineState; (function (TokenClass) { TokenClass[TokenClass["Punctuation"] = 0] = "Punctuation"; TokenClass[TokenClass["Keyword"] = 1] = "Keyword"; @@ -36672,52 +31057,29 @@ var ts; TokenClass[TokenClass["RegExpLiteral"] = 8] = "RegExpLiteral"; })(ts.TokenClass || (ts.TokenClass = {})); var TokenClass = ts.TokenClass; - // TODO: move these to enums var ScriptElementKind; (function (ScriptElementKind) { ScriptElementKind.unknown = ""; ScriptElementKind.warning = "warning"; - // predefined type (void) or keyword (class) ScriptElementKind.keyword = "keyword"; - // top level script node ScriptElementKind.scriptElement = "script"; - // module foo {} ScriptElementKind.moduleElement = "module"; - // class X {} ScriptElementKind.classElement = "class"; - // interface Y {} ScriptElementKind.interfaceElement = "interface"; - // type T = ... ScriptElementKind.typeElement = "type"; - // enum E ScriptElementKind.enumElement = "enum"; - // Inside module and script only - // let v = .. ScriptElementKind.variableElement = "var"; - // Inside function ScriptElementKind.localVariableElement = "local var"; - // Inside module and script only - // function f() { } ScriptElementKind.functionElement = "function"; - // Inside function ScriptElementKind.localFunctionElement = "local function"; - // class X { [public|private]* foo() {} } ScriptElementKind.memberFunctionElement = "method"; - // class X { [public|private]* [get|set] foo:number; } ScriptElementKind.memberGetAccessorElement = "getter"; ScriptElementKind.memberSetAccessorElement = "setter"; - // class X { [public|private]* foo:number; } - // interface Y { foo:number; } ScriptElementKind.memberVariableElement = "property"; - // class X { constructor() { } } ScriptElementKind.constructorImplementationElement = "constructor"; - // interface Y { ():number; } ScriptElementKind.callSignatureElement = "call"; - // interface Y { []:number; } ScriptElementKind.indexSignatureElement = "index"; - // interface Y { new():Y; } ScriptElementKind.constructSignatureElement = "construct"; - // function foo(*Y*: string) ScriptElementKind.parameterElement = "parameter"; ScriptElementKind.typeParameterElement = "type parameter"; ScriptElementKind.primitiveType = "primitive type"; @@ -36758,26 +31120,6 @@ var ts; return ClassificationTypeNames; })(); ts.ClassificationTypeNames = ClassificationTypeNames; - (function (ClassificationType) { - ClassificationType[ClassificationType["comment"] = 1] = "comment"; - ClassificationType[ClassificationType["identifier"] = 2] = "identifier"; - ClassificationType[ClassificationType["keyword"] = 3] = "keyword"; - ClassificationType[ClassificationType["numericLiteral"] = 4] = "numericLiteral"; - ClassificationType[ClassificationType["operator"] = 5] = "operator"; - ClassificationType[ClassificationType["stringLiteral"] = 6] = "stringLiteral"; - ClassificationType[ClassificationType["regularExpressionLiteral"] = 7] = "regularExpressionLiteral"; - ClassificationType[ClassificationType["whiteSpace"] = 8] = "whiteSpace"; - ClassificationType[ClassificationType["text"] = 9] = "text"; - ClassificationType[ClassificationType["punctuation"] = 10] = "punctuation"; - ClassificationType[ClassificationType["className"] = 11] = "className"; - ClassificationType[ClassificationType["enumName"] = 12] = "enumName"; - ClassificationType[ClassificationType["interfaceName"] = 13] = "interfaceName"; - ClassificationType[ClassificationType["moduleName"] = 14] = "moduleName"; - ClassificationType[ClassificationType["typeParameterName"] = 15] = "typeParameterName"; - ClassificationType[ClassificationType["typeAliasName"] = 16] = "typeAliasName"; - ClassificationType[ClassificationType["parameterName"] = 17] = "parameterName"; - })(ts.ClassificationType || (ts.ClassificationType = {})); - var ClassificationType = ts.ClassificationType; function displayPartsToString(displayParts) { if (displayParts) { return ts.map(displayParts, function (displayPart) { return displayPart.text; }).join(""); @@ -36787,32 +31129,27 @@ var ts; ts.displayPartsToString = displayPartsToString; function isLocalVariableOrFunction(symbol) { if (symbol.parent) { - return false; // This is exported symbol + return false; } return ts.forEach(symbol.declarations, function (declaration) { - // Function expressions are local - if (declaration.kind === 163 /* FunctionExpression */) { + if (declaration.kind === 163) { return true; } - if (declaration.kind !== 199 /* VariableDeclaration */ && declaration.kind !== 201 /* FunctionDeclaration */) { + if (declaration.kind !== 199 && declaration.kind !== 201) { return false; } - // If the parent is not sourceFile or module block it is local variable for (var parent_7 = declaration.parent; !ts.isFunctionBlock(parent_7); parent_7 = parent_7.parent) { - // Reached source file or module block - if (parent_7.kind === 228 /* SourceFile */ || parent_7.kind === 207 /* ModuleBlock */) { + if (parent_7.kind === 228 || parent_7.kind === 207) { return false; } } - // parent is in function block return true; }); } function getDefaultCompilerOptions() { - // Always default to "ScriptTarget.ES5" for the language service return { - target: 1 /* ES5 */, - module: 0 /* None */ + target: 1, + module: 0 }; } ts.getDefaultCompilerOptions = getDefaultCompilerOptions; @@ -36838,21 +31175,15 @@ var ts; return CancellationTokenObject; })(); ts.CancellationTokenObject = CancellationTokenObject; - // Cache host information about scrip Should be refreshed - // at each language service public entry point, since we don't know when - // set of scripts handled by the host changes. var HostCache = (function () { function HostCache(host) { this.host = host; - // script id => script index this.fileNameToEntry = {}; - // Initialize the list with the root file names var rootFileNames = host.getScriptFileNames(); for (var _i = 0; _i < rootFileNames.length; _i++) { var fileName = rootFileNames[_i]; this.createEntry(fileName); } - // store the compilation settings this._compilationSettings = host.getCompilationSettings() || getDefaultCompilerOptions(); } HostCache.prototype.compilationSettings = function () { @@ -36908,22 +31239,18 @@ var ts; SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) { var scriptSnapshot = this.host.getScriptSnapshot(fileName); if (!scriptSnapshot) { - // The host does not know about this file. throw new Error("Could not find file: '" + fileName + "'."); } var version = this.host.getScriptVersion(fileName); var sourceFile; if (this.currentFileName !== fileName) { - // This is a new file, just parse it - sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, 2 /* Latest */, version, true); + sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, 2, version, true); } else if (this.currentFileVersion !== version) { - // This is the same file, just a newer version. Incrementally parse the file. var editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot); sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange); } if (sourceFile) { - // All done, ensure state is up to date this.currentFileVersion = version; this.currentFileName = fileName; this.currentFileScriptSnapshot = scriptSnapshot; @@ -36937,28 +31264,16 @@ var ts; sourceFile.version = version; sourceFile.scriptSnapshot = scriptSnapshot; } - /* - * This function will compile source text from 'input' argument using specified compiler options. - * If not options are provided - it will use a set of default compiler options. - * Extra compiler options that will unconditionally be used bu this function are: - * - separateCompilation = true - * - allowNonTsExtensions = true - */ function transpile(input, compilerOptions, fileName, diagnostics) { var options = compilerOptions ? ts.clone(compilerOptions) : getDefaultCompilerOptions(); options.separateCompilation = true; - // Filename can be non-ts file. options.allowNonTsExtensions = true; - // Parse var inputFileName = fileName || "module.ts"; var sourceFile = ts.createSourceFile(inputFileName, input, options.target); - // Store syntactic diagnostics if (diagnostics && sourceFile.parseDiagnostics) { diagnostics.push.apply(diagnostics, sourceFile.parseDiagnostics); } - // Output var outputText; - // Create a compilerHost object to allow the compiler to read and write files var compilerHost = { getSourceFile: function (fileName, target) { return fileName === inputFileName ? sourceFile : undefined; }, writeFile: function (name, text, writeByteOrderMark) { @@ -36975,7 +31290,6 @@ var ts; if (diagnostics) { diagnostics.push.apply(diagnostics, program.getGlobalDiagnostics()); } - // Emit program.emit(); ts.Debug.assert(outputText !== undefined, "Output generation failed"); return outputText; @@ -36984,38 +31298,29 @@ var ts; function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTarget, version, setNodeParents) { var sourceFile = ts.createSourceFile(fileName, scriptSnapshot.getText(0, scriptSnapshot.getLength()), scriptTarget, setNodeParents); setSourceFileFields(sourceFile, scriptSnapshot, version); - // after full parsing we can use table with interned strings as name table sourceFile.nameTable = sourceFile.identifiers; return sourceFile; } ts.createLanguageServiceSourceFile = createLanguageServiceSourceFile; ts.disableIncrementalParsing = false; function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version, textChangeRange, aggressiveChecks) { - // If we were given a text change range, and our version or open-ness changed, then - // incrementally parse this file. if (textChangeRange) { if (version !== sourceFile.version) { - // Once incremental parsing is ready, then just call into this function. if (!ts.disableIncrementalParsing) { var newSourceFile = ts.updateSourceFile(sourceFile, scriptSnapshot.getText(0, scriptSnapshot.getLength()), textChangeRange, aggressiveChecks); setSourceFileFields(newSourceFile, scriptSnapshot, version); - // after incremental parsing nameTable might not be up-to-date - // drop it so it can be lazily recreated later newSourceFile.nameTable = undefined; return newSourceFile; } } } - // Otherwise, just create a new source file. return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; function createDocumentRegistry() { - // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have - // for those settings. var buckets = {}; function getKeyFromCompilationSettings(settings) { - return "_" + settings.target; // + "|" + settings.propagateEnumConstantoString() + return "_" + settings.target; } function getBucketForCompilationSettings(settings, createIfMissing) { var key = getKeyFromCompilationSettings(settings); @@ -37056,7 +31361,6 @@ var ts; var entry = ts.lookUp(bucket, fileName); if (!entry) { ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); - // Have never seen this file with these settings. Create a new source file for it. var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); bucket[fileName] = entry = { sourceFile: sourceFile, @@ -37065,18 +31369,10 @@ var ts; }; } else { - // We have an entry for this file. However, it may be for a different version of - // the script snapshot. If so, update it appropriately. Otherwise, we can just - // return it as is. if (entry.sourceFile.version !== version) { entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot)); } } - // If we're acquiring, then this is the first time this LS is asking for this document. - // Increase our ref count so we know there's another LS using the document. If we're - // not acquiring, then that means the LS is 'updating' the file instead, and that means - // it has already acquired the document previously. As such, we do not need to increase - // the ref count. if (acquiring) { entry.languageServiceRefCount++; } @@ -37131,87 +31427,67 @@ var ts; function processImport() { scanner.setText(sourceText); var token = scanner.scan(); - // Look for: - // import "mod"; - // import d from "mod" - // import {a as A } from "mod"; - // import * as NS from "mod" - // import d, {a, b as B} from "mod" - // import i = require("mod"); - // - // export * from "mod" - // export {a as b} from "mod" - while (token !== 1 /* EndOfFileToken */) { - if (token === 85 /* ImportKeyword */) { + while (token !== 1) { + if (token === 85) { token = scanner.scan(); - if (token === 8 /* StringLiteral */) { - // import "mod"; + if (token === 8) { recordModuleName(); continue; } else { - if (token === 65 /* Identifier */) { + if (token === 65) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 125) { token = scanner.scan(); - if (token === 8 /* StringLiteral */) { - // import d from "mod"; + if (token === 8) { recordModuleName(); continue; } } - else if (token === 53 /* EqualsToken */) { + else if (token === 53) { token = scanner.scan(); - if (token === 119 /* RequireKeyword */) { + if (token === 119) { token = scanner.scan(); - if (token === 16 /* OpenParenToken */) { + if (token === 16) { token = scanner.scan(); - if (token === 8 /* StringLiteral */) { - // import i = require("mod"); + if (token === 8) { recordModuleName(); continue; } } } } - else if (token === 23 /* CommaToken */) { - // consume comma and keep going + else if (token === 23) { token = scanner.scan(); } else { - // unknown syntax continue; } } - if (token === 14 /* OpenBraceToken */) { + if (token === 14) { token = scanner.scan(); - // consume "{ a as B, c, d as D}" clauses - while (token !== 15 /* CloseBraceToken */) { + while (token !== 15) { token = scanner.scan(); } - if (token === 15 /* CloseBraceToken */) { + if (token === 15) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 125) { token = scanner.scan(); - if (token === 8 /* StringLiteral */) { - // import {a as A} from "mod"; - // import d, {a, b as B} from "mod" + if (token === 8) { recordModuleName(); } } } } - else if (token === 35 /* AsteriskToken */) { + else if (token === 35) { token = scanner.scan(); - if (token === 111 /* AsKeyword */) { + if (token === 111) { token = scanner.scan(); - if (token === 65 /* Identifier */) { + if (token === 65) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 125) { token = scanner.scan(); - if (token === 8 /* StringLiteral */) { - // import * as NS from "mod" - // import d, * as NS from "mod" + if (token === 8) { recordModuleName(); } } @@ -37220,32 +31496,28 @@ var ts; } } } - else if (token === 78 /* ExportKeyword */) { + else if (token === 78) { token = scanner.scan(); - if (token === 14 /* OpenBraceToken */) { + if (token === 14) { token = scanner.scan(); - // consume "{ a as B, c, d as D}" clauses - while (token !== 15 /* CloseBraceToken */) { + while (token !== 15) { token = scanner.scan(); } - if (token === 15 /* CloseBraceToken */) { + if (token === 15) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 125) { token = scanner.scan(); - if (token === 8 /* StringLiteral */) { - // export {a as A} from "mod"; - // export {a, b as B} from "mod" + if (token === 8) { recordModuleName(); } } } } - else if (token === 35 /* AsteriskToken */) { + else if (token === 35) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 125) { token = scanner.scan(); - if (token === 8 /* StringLiteral */) { - // export * from "mod" + if (token === 8) { recordModuleName(); } } @@ -37262,10 +31534,9 @@ var ts; return { referencedFiles: referencedFiles, importedFiles: importedFiles, isLibFile: isNoDefaultLib }; } ts.preProcessFile = preProcessFile; - /// Helpers function getTargetLabel(referenceNode, labelName) { while (referenceNode) { - if (referenceNode.kind === 195 /* LabeledStatement */ && referenceNode.label.text === labelName) { + if (referenceNode.kind === 195 && referenceNode.label.text === labelName) { return referenceNode.label; } referenceNode = referenceNode.parent; @@ -37273,21 +31544,17 @@ var ts; return undefined; } function isJumpStatementTarget(node) { - return node.kind === 65 /* Identifier */ && - (node.parent.kind === 191 /* BreakStatement */ || node.parent.kind === 190 /* ContinueStatement */) && + return node.kind === 65 && + (node.parent.kind === 191 || node.parent.kind === 190) && node.parent.label === node; } function isLabelOfLabeledStatement(node) { - return node.kind === 65 /* Identifier */ && - node.parent.kind === 195 /* LabeledStatement */ && + return node.kind === 65 && + node.parent.kind === 195 && node.parent.label === node; } - /** - * Whether or not a 'node' is preceded by a label of the given string. - * Note: 'node' cannot be a SourceFile. - */ function isLabeledBy(node, labelName) { - for (var owner = node.parent; owner.kind === 195 /* LabeledStatement */; owner = owner.parent) { + for (var owner = node.parent; owner.kind === 195; owner = owner.parent) { if (owner.label.text === labelName) { return true; } @@ -37298,108 +31565,86 @@ var ts; return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); } function isRightSideOfQualifiedName(node) { - return node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node; + return node.parent.kind === 127 && node.parent.right === node; } function isRightSideOfPropertyAccess(node) { - return node && node.parent && node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node; + return node && node.parent && node.parent.kind === 156 && node.parent.name === node; } function isCallExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 158 /* CallExpression */ && node.parent.expression === node; + return node && node.parent && node.parent.kind === 158 && node.parent.expression === node; } function isNewExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 159 /* NewExpression */ && node.parent.expression === node; + return node && node.parent && node.parent.kind === 159 && node.parent.expression === node; } function isNameOfModuleDeclaration(node) { - return node.parent.kind === 206 /* ModuleDeclaration */ && node.parent.name === node; + return node.parent.kind === 206 && node.parent.name === node; } function isNameOfFunctionDeclaration(node) { - return node.kind === 65 /* Identifier */ && + return node.kind === 65 && ts.isFunctionLike(node.parent) && node.parent.name === node; } - /** Returns true if node is a name of an object literal property, e.g. "a" in x = { "a": 1 } */ function isNameOfPropertyAssignment(node) { - return (node.kind === 65 /* Identifier */ || node.kind === 8 /* StringLiteral */ || node.kind === 7 /* NumericLiteral */) && - (node.parent.kind === 225 /* PropertyAssignment */ || node.parent.kind === 226 /* ShorthandPropertyAssignment */) && node.parent.name === node; + return (node.kind === 65 || node.kind === 8 || node.kind === 7) && + (node.parent.kind === 225 || node.parent.kind === 226) && node.parent.name === node; } function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { - if (node.kind === 8 /* StringLiteral */ || node.kind === 7 /* NumericLiteral */) { + if (node.kind === 8 || node.kind === 7) { switch (node.parent.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 206 /* ModuleDeclaration */: + case 133: + case 132: + case 225: + case 227: + case 135: + case 134: + case 137: + case 138: + case 206: return node.parent.name === node; - case 157 /* ElementAccessExpression */: + case 157: return node.parent.argumentExpression === node; } } return false; } function isNameOfExternalModuleImportOrDeclaration(node) { - if (node.kind === 8 /* StringLiteral */) { + if (node.kind === 8) { return isNameOfModuleDeclaration(node) || (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node); } return false; } - /** Returns true if the position is within a comment */ function isInsideComment(sourceFile, token, position) { - // The position has to be: 1. in the leading trivia (before token.getStart()), and 2. within a comment return position <= token.getStart(sourceFile) && (isInsideCommentRange(ts.getTrailingCommentRanges(sourceFile.text, token.getFullStart())) || isInsideCommentRange(ts.getLeadingCommentRanges(sourceFile.text, token.getFullStart()))); function isInsideCommentRange(comments) { return ts.forEach(comments, function (comment) { - // either we are 1. completely inside the comment, or 2. at the end of the comment if (comment.pos < position && position < comment.end) { return true; } else if (position === comment.end) { var text = sourceFile.text; var width = comment.end - comment.pos; - // is single line comment or just /* - if (width <= 2 || text.charCodeAt(comment.pos + 1) === 47 /* slash */) { + if (width <= 2 || text.charCodeAt(comment.pos + 1) === 47) { return true; } else { - // is unterminated multi-line comment - return !(text.charCodeAt(comment.end - 1) === 47 /* slash */ && - text.charCodeAt(comment.end - 2) === 42 /* asterisk */); + return !(text.charCodeAt(comment.end - 1) === 47 && + text.charCodeAt(comment.end - 2) === 42); } } return false; }); } } - var SemanticMeaning; - (function (SemanticMeaning) { - SemanticMeaning[SemanticMeaning["None"] = 0] = "None"; - SemanticMeaning[SemanticMeaning["Value"] = 1] = "Value"; - SemanticMeaning[SemanticMeaning["Type"] = 2] = "Type"; - SemanticMeaning[SemanticMeaning["Namespace"] = 4] = "Namespace"; - SemanticMeaning[SemanticMeaning["All"] = 7] = "All"; - })(SemanticMeaning || (SemanticMeaning = {})); - var BreakContinueSearchType; - (function (BreakContinueSearchType) { - BreakContinueSearchType[BreakContinueSearchType["None"] = 0] = "None"; - BreakContinueSearchType[BreakContinueSearchType["Unlabeled"] = 1] = "Unlabeled"; - BreakContinueSearchType[BreakContinueSearchType["Labeled"] = 2] = "Labeled"; - BreakContinueSearchType[BreakContinueSearchType["All"] = 3] = "All"; - })(BreakContinueSearchType || (BreakContinueSearchType = {})); - // A cache of completion entries for keywords, these do not change between sessions var keywordCompletions = []; - for (var i = 66 /* FirstKeyword */; i <= 126 /* LastKeyword */; i++) { + for (var i = 66; i <= 126; i++) { keywordCompletions.push({ name: ts.tokenToString(i), kind: ScriptElementKind.keyword, @@ -37407,63 +31652,63 @@ var ts; sortText: "0" }); } - /* @internal */ function getContainerNode(node) { + function getContainerNode(node) { while (true) { node = node.parent; if (!node) { return undefined; } switch (node.kind) { - case 228 /* SourceFile */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: + case 228: + case 135: + case 134: + case 201: + case 163: + case 137: + case 138: + case 202: + case 203: + case 205: + case 206: return node; } } } ts.getContainerNode = getContainerNode; - /* @internal */ function getNodeKind(node) { + function getNodeKind(node) { switch (node.kind) { - case 206 /* ModuleDeclaration */: return ScriptElementKind.moduleElement; - case 202 /* ClassDeclaration */: return ScriptElementKind.classElement; - case 203 /* InterfaceDeclaration */: return ScriptElementKind.interfaceElement; - case 204 /* TypeAliasDeclaration */: return ScriptElementKind.typeElement; - case 205 /* EnumDeclaration */: return ScriptElementKind.enumElement; - case 199 /* VariableDeclaration */: + case 206: return ScriptElementKind.moduleElement; + case 202: return ScriptElementKind.classElement; + case 203: return ScriptElementKind.interfaceElement; + case 204: return ScriptElementKind.typeElement; + case 205: return ScriptElementKind.enumElement; + case 199: return ts.isConst(node) ? ScriptElementKind.constElement : ts.isLet(node) ? ScriptElementKind.letElement : ScriptElementKind.variableElement; - case 201 /* FunctionDeclaration */: return ScriptElementKind.functionElement; - case 137 /* GetAccessor */: return ScriptElementKind.memberGetAccessorElement; - case 138 /* SetAccessor */: return ScriptElementKind.memberSetAccessorElement; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 201: return ScriptElementKind.functionElement; + case 137: return ScriptElementKind.memberGetAccessorElement; + case 138: return ScriptElementKind.memberSetAccessorElement; + case 135: + case 134: return ScriptElementKind.memberFunctionElement; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 133: + case 132: return ScriptElementKind.memberVariableElement; - case 141 /* IndexSignature */: return ScriptElementKind.indexSignatureElement; - case 140 /* ConstructSignature */: return ScriptElementKind.constructSignatureElement; - case 139 /* CallSignature */: return ScriptElementKind.callSignatureElement; - case 136 /* Constructor */: return ScriptElementKind.constructorImplementationElement; - case 129 /* TypeParameter */: return ScriptElementKind.typeParameterElement; - case 227 /* EnumMember */: return ScriptElementKind.variableElement; - case 130 /* Parameter */: return (node.flags & 112 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 211 /* ImportClause */: - case 218 /* ExportSpecifier */: - case 212 /* NamespaceImport */: + case 141: return ScriptElementKind.indexSignatureElement; + case 140: return ScriptElementKind.constructSignatureElement; + case 139: return ScriptElementKind.callSignatureElement; + case 136: return ScriptElementKind.constructorImplementationElement; + case 129: return ScriptElementKind.typeParameterElement; + case 227: return ScriptElementKind.variableElement; + case 130: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; + case 209: + case 214: + case 211: + case 218: + case 212: return ScriptElementKind.alias; } return ScriptElementKind.unknown; @@ -37476,7 +31721,6 @@ var ts; var program; var useCaseSensitivefileNames = false; var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken()); - // Check if the localized messages json is set, otherwise query the host for it if (!ts.localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) { ts.localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages(); } @@ -37497,7 +31741,6 @@ var ts; return sourceFile; } function getRuleProvider(options) { - // Ensure rules are initialized and up to date wrt to formatting options if (!ruleProvider) { ruleProvider = new ts.formatting.RulesProvider(); } @@ -37505,21 +31748,13 @@ var ts; return ruleProvider; } function synchronizeHostData() { - // Get a fresh cache of the host information var hostCache = new HostCache(host); - // If the program is already up-to-date, we can reuse it if (programUpToDate()) { return; } - // IMPORTANT - It is critical from this moment onward that we do not check - // cancellation tokens. We are about to mutate source files from a previous program - // instance. If we cancel midway through, we may end up in an inconsistent state where - // the program points to old source files that have been invalidated because of - // incremental parsing. var oldSettings = program && program.getCompilerOptions(); var newSettings = hostCache.compilationSettings(); var changesInCompilationSettingsAffectSyntax = oldSettings && oldSettings.target !== newSettings.target; - // Now create a new compiler var newProgram = ts.createProgram(hostCache.getRootFileNames(), newSettings, { getSourceFile: getOrCreateSourceFile, getCancellationToken: function () { return cancellationToken; }, @@ -37530,8 +31765,6 @@ var ts; writeFile: function (fileName, data, writeByteOrderMark) { }, getCurrentDirectory: function () { return host.getCurrentDirectory(); } }); - // Release any files we have acquired in the old program but are - // not part of the new program. if (program) { var oldSourceFiles = program.getSourceFiles(); for (var _i = 0; _i < oldSourceFiles.length; _i++) { @@ -37543,73 +31776,38 @@ var ts; } } program = newProgram; - // Make sure all the nodes in the program are both bound, and have their parent - // pointers set property. program.getTypeChecker(); return; function getOrCreateSourceFile(fileName) { - // The program is asking for this file, check first if the host can locate it. - // If the host can not locate the file, then it does not exist. return undefined - // to the program to allow reporting of errors for missing files. var hostFileInformation = hostCache.getOrCreateEntry(fileName); if (!hostFileInformation) { return undefined; } - // Check if the language version has changed since we last created a program; if they are the same, - // it is safe to reuse the souceFiles; if not, then the shape of the AST can change, and the oldSourceFile - // can not be reused. we have to dump all syntax trees and create new ones. if (!changesInCompilationSettingsAffectSyntax) { - // Check if the old program had this file already var oldSourceFile = program && program.getSourceFile(fileName); if (oldSourceFile) { - // We already had a source file for this file name. Go to the registry to - // ensure that we get the right up to date version of it. We need this to - // address the following 'race'. Specifically, say we have the following: - // - // LS1 - // \ - // DocumentRegistry - // / - // LS2 - // - // Each LS has a reference to file 'foo.ts' at version 1. LS2 then updates - // it's version of 'foo.ts' to version 2. This will cause LS2 and the - // DocumentRegistry to have version 2 of the document. HOwever, LS1 will - // have version 1. And *importantly* this source file will be *corrupt*. - // The act of creating version 2 of the file irrevocably damages the version - // 1 file. - // - // So, later when we call into LS1, we need to make sure that it doesn't use - // it's source file any more, and instead defers to DocumentRegistry to get - // either version 1, version 2 (or some other version) depending on what the - // host says should be used. return documentRegistry.updateDocument(fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version); } } - // Could not find this file in the old program, create a new SourceFile for it. return documentRegistry.acquireDocument(fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version); } function sourceFileUpToDate(sourceFile) { return sourceFile && sourceFile.version === hostCache.getVersion(sourceFile.fileName); } function programUpToDate() { - // If we haven't create a program yet, then it is not up-to-date if (!program) { return false; } - // If number of files in the program do not match, it is not up-to-date var rootFileNames = hostCache.getRootFileNames(); if (program.getSourceFiles().length !== rootFileNames.length) { return false; } - // If any file is not up-to-date, then the whole program is not up-to-date for (var _i = 0; _i < rootFileNames.length; _i++) { var fileName = rootFileNames[_i]; if (!sourceFileUpToDate(program.getSourceFile(fileName))) { return false; } } - // If the compilation settings do no match, then the program is not up-to-date return ts.compareDataObjects(program.getCompilerOptions(), hostCache.compilationSettings()); } } @@ -37618,7 +31816,6 @@ var ts; return program; } function cleanupSemanticCache() { - // TODO: Should we jettison the program (or it's type checker) here? } function dispose() { if (program) { @@ -37627,31 +31824,20 @@ var ts; }); } } - /// Diagnostics function getSyntacticDiagnostics(fileName) { synchronizeHostData(); return program.getSyntacticDiagnostics(getValidSourceFile(fileName)); } - /** - * getSemanticDiagnostiscs return array of Diagnostics. If '-d' is not enabled, only report semantic errors - * If '-d' enabled, report both semantic and emitter errors - */ function getSemanticDiagnostics(fileName) { synchronizeHostData(); var targetSourceFile = getValidSourceFile(fileName); - // For JavaScript files, we don't want to report the normal typescript semantic errors. - // Instead, we just report errors for using TypeScript-only constructs from within a - // JavaScript file. if (ts.isJavaScript(fileName)) { return getJavaScriptSemanticDiagnostics(targetSourceFile); } - // Only perform the action per file regardless of '-out' flag as LanguageServiceHost is expected to call this function per file. - // Therefore only get diagnostics for given file. var semanticDiagnostics = program.getSemanticDiagnostics(targetSourceFile); if (!program.getCompilerOptions().declaration) { return semanticDiagnostics; } - // If '-d' is enabled, check for emitter error. One example of emitter error is export class implements non-export interface var declarationDiagnostics = program.getDeclarationDiagnostics(targetSourceFile); return ts.concatenate(semanticDiagnostics, declarationDiagnostics); } @@ -37664,44 +31850,44 @@ var ts; return false; } switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: + case 209: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_a_ts_file)); return true; - case 215 /* ExportAssignment */: + case 215: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_a_ts_file)); return true; - case 202 /* ClassDeclaration */: + case 202: var classDeclaration = node; if (checkModifiers(classDeclaration.modifiers) || checkTypeParameters(classDeclaration.typeParameters)) { return true; } break; - case 223 /* HeritageClause */: + case 223: var heritageClause = node; - if (heritageClause.token === 102 /* ImplementsKeyword */) { + if (heritageClause.token === 102) { diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file)); return true; } break; - case 203 /* InterfaceDeclaration */: + case 203: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file)); return true; - case 206 /* ModuleDeclaration */: + case 206: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.module_declarations_can_only_be_used_in_a_ts_file)); return true; - case 204 /* TypeAliasDeclaration */: + case 204: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.type_aliases_can_only_be_used_in_a_ts_file)); return true; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 201 /* FunctionDeclaration */: + case 135: + case 134: + case 136: + case 137: + case 138: + case 163: + case 201: + case 164: + case 201: var functionDeclaration = node; if (checkModifiers(functionDeclaration.modifiers) || checkTypeParameters(functionDeclaration.typeParameters) || @@ -37709,20 +31895,20 @@ var ts; return true; } break; - case 181 /* VariableStatement */: + case 181: var variableStatement = node; if (checkModifiers(variableStatement.modifiers)) { return true; } break; - case 199 /* VariableDeclaration */: + case 199: var variableDeclaration = node; if (checkTypeAnnotation(variableDeclaration.type)) { return true; } break; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 158: + case 159: var expression = node; if (expression.typeArguments && expression.typeArguments.length > 0) { var start = expression.typeArguments.pos; @@ -37730,7 +31916,7 @@ var ts; return true; } break; - case 130 /* Parameter */: + case 130: var parameter = node; if (parameter.modifiers) { var start = parameter.modifiers.pos; @@ -37746,17 +31932,17 @@ var ts; return true; } break; - case 133 /* PropertyDeclaration */: + case 133: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.property_declarations_can_only_be_used_in_a_ts_file)); return true; - case 205 /* EnumDeclaration */: + case 205: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file)); return true; - case 161 /* TypeAssertionExpression */: + case 161: var typeAssertionExpression = node; diagnostics.push(ts.createDiagnosticForNode(typeAssertionExpression.type, ts.Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file)); return true; - case 131 /* Decorator */: + case 131: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.decorators_can_only_be_used_in_a_ts_file)); return true; } @@ -37782,17 +31968,16 @@ var ts; for (var _i = 0; _i < modifiers.length; _i++) { var modifier = modifiers[_i]; switch (modifier.kind) { - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: - case 115 /* DeclareKeyword */: + case 108: + case 106: + case 107: + case 115: diagnostics.push(ts.createDiagnosticForNode(modifier, ts.Diagnostics._0_can_only_be_used_in_a_ts_file, ts.tokenToString(modifier.kind))); return true; - // These are all legal modifiers. - case 109 /* StaticKeyword */: - case 78 /* ExportKeyword */: - case 70 /* ConstKeyword */: - case 73 /* DefaultKeyword */: + case 109: + case 78: + case 70: + case 73: } } } @@ -37803,11 +31988,9 @@ var ts; synchronizeHostData(); return program.getGlobalDiagnostics(); } - /// Completion function getCompletionEntryDisplayNameForSymbol(symbol, target, performCharacterChecks) { var displayName = symbol.getName(); if (displayName) { - // If this is the default export, get the name of the declaration if it exists if (displayName === "default") { var localSymbol = ts.getLocalSymbolForExportDefault(symbol); if (localSymbol && localSymbol.name) { @@ -37815,10 +31998,7 @@ var ts; } } var firstCharCode = displayName.charCodeAt(0); - // First check of the displayName is not external module; if it is an external module, it is not valid entry - if ((symbol.flags & 1536 /* Namespace */) && (firstCharCode === 39 /* singleQuote */ || firstCharCode === 34 /* doubleQuote */)) { - // If the symbol is external module, don't show it in the completion list - // (i.e declare module "http" { let x; } | // <= request completion here, "http" should not be there) + if ((symbol.flags & 1536) && (firstCharCode === 39 || firstCharCode === 34)) { return undefined; } } @@ -37831,9 +32011,7 @@ var ts; var firstCharCode = displayName.charCodeAt(0); if (displayName.length >= 2 && firstCharCode === displayName.charCodeAt(displayName.length - 1) && - (firstCharCode === 39 /* singleQuote */ || firstCharCode === 34 /* doubleQuote */)) { - // If the user entered name for the symbol was quoted, removing the quotes is not enough, as the name could be an - // invalid identifier name. We need to check if whatever was inside the quotes is actually a valid identifier name. + (firstCharCode === 39 || firstCharCode === 34)) { displayName = displayName.substring(1, displayName.length - 1); } if (!displayName) { @@ -37859,7 +32037,6 @@ var ts; var currentToken = ts.getTokenAtPosition(sourceFile, position); log("getCompletionData: Get current token: " + (new Date().getTime() - start)); start = new Date().getTime(); - // Completion not allowed inside comments, bail out if this is the case var insideComment = isInsideComment(sourceFile, currentToken, position); log("getCompletionData: Is inside comment: " + (new Date().getTime() - start)); if (insideComment) { @@ -37869,31 +32046,23 @@ var ts; start = new Date().getTime(); var previousToken = ts.findPrecedingToken(position, sourceFile); log("getCompletionData: Get previous token 1: " + (new Date().getTime() - start)); - // The decision to provide completion depends on the contextToken, which is determined through the previousToken. - // Note: 'previousToken' (and thus 'contextToken') can be undefined if we are the beginning of the file var contextToken = previousToken; - // Check if the caret is at the end of an identifier; this is a partial identifier that we want to complete: e.g. a.toS| - // Skip this partial identifier and adjust the contextToken to the token that precedes it. if (contextToken && position <= contextToken.end && ts.isWord(contextToken.kind)) { var start_2 = new Date().getTime(); contextToken = ts.findPrecedingToken(contextToken.getFullStart(), sourceFile); log("getCompletionData: Get previous token 2: " + (new Date().getTime() - start_2)); } - // Check if this is a valid completion location if (contextToken && isCompletionListBlocker(contextToken)) { log("Returning an empty list because completion was requested in an invalid position."); return undefined; } - // Find the node where completion is requested on, in the case of a completion after - // a dot, it is the member access expression other wise, it is a request for all - // visible symbols in the scope, and the node is the current location. var node = currentToken; var isRightOfDot = false; - if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 156 /* PropertyAccessExpression */) { + if (contextToken && contextToken.kind === 20 && contextToken.parent.kind === 156) { node = contextToken.parent.expression; isRightOfDot = true; } - else if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 127 /* QualifiedName */) { + else if (contextToken && contextToken.kind === 20 && contextToken.parent.kind === 127) { node = contextToken.parent.left; isRightOfDot = true; } @@ -37907,9 +32076,6 @@ var ts; getTypeScriptMemberSymbols(); } else { - // For JavaScript or TypeScript, if we're not after a dot, then just try to get the - // global symbols in scope. These results should be valid for either language as - // the set of symbols that can be referenced from this location. if (!tryGetGlobalSymbols()) { return undefined; } @@ -37917,17 +32083,14 @@ var ts; log("getCompletionData: Semantic work: " + (new Date().getTime() - semanticStart)); return { symbols: symbols, isMemberCompletion: isMemberCompletion, isNewIdentifierLocation: isNewIdentifierLocation, location: location, isRightOfDot: isRightOfDot }; function getTypeScriptMemberSymbols() { - // Right of dot member completion list isMemberCompletion = true; isNewIdentifierLocation = false; - if (node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */ || node.kind === 156 /* PropertyAccessExpression */) { + if (node.kind === 65 || node.kind === 127 || node.kind === 156) { var symbol = typeChecker.getSymbolAtLocation(node); - // This is an alias, follow what it aliases - if (symbol && symbol.flags & 8388608 /* Alias */) { + if (symbol && symbol.flags & 8388608) { symbol = typeChecker.getAliasedSymbol(symbol); } - if (symbol && symbol.flags & 1952 /* HasExports */) { - // Extract module or enum members + if (symbol && symbol.flags & 1952) { var exportedSymbols = typeChecker.getExportsOfModule(symbol); ts.forEach(exportedSymbols, function (symbol) { if (typeChecker.isValidPropertyAccess((node.parent), symbol.name)) { @@ -37938,7 +32101,6 @@ var ts; } var type = typeChecker.getTypeAtLocation(node); if (type) { - // Filter private properties ts.forEach(type.getApparentProperties(), function (symbol) { if (typeChecker.isValidPropertyAccess((node.parent), symbol.name)) { symbols.push(symbol); @@ -37949,7 +32111,6 @@ var ts; function tryGetGlobalSymbols() { var containingObjectLiteral = getContainingObjectLiteralApplicableForCompletion(contextToken); if (containingObjectLiteral) { - // Object literal expression, look up possible property names from contextual type isMemberCompletion = true; isNewIdentifierLocation = true; var contextualType = typeChecker.getContextualType(containingObjectLiteral); @@ -37958,17 +32119,14 @@ var ts; } var contextualTypeMembers = typeChecker.getPropertiesOfType(contextualType); if (contextualTypeMembers && contextualTypeMembers.length > 0) { - // Add filtered items to the completion list symbols = filterContextualMembersList(contextualTypeMembers, containingObjectLiteral.properties); } } - else if (ts.getAncestor(contextToken, 211 /* ImportClause */)) { - // cursor is in import clause - // try to show exported member for imported module + else if (ts.getAncestor(contextToken, 211)) { isMemberCompletion = true; isNewIdentifierLocation = true; if (showCompletionsInImportsClause(contextToken)) { - var importDeclaration = ts.getAncestor(contextToken, 210 /* ImportDeclaration */); + var importDeclaration = ts.getAncestor(contextToken, 210); ts.Debug.assert(importDeclaration !== undefined); var exports_2; if (importDeclaration.moduleSpecifier) { @@ -37977,56 +32135,24 @@ var ts; exports_2 = typeChecker.getExportsOfModule(moduleSpecifierSymbol); } } - //let exports = typeInfoResolver.getExportsOfImportDeclaration(importDeclaration); symbols = exports_2 ? filterModuleExports(exports_2, importDeclaration) : emptyArray; } } else { - // Get all entities in the current scope. isMemberCompletion = false; isNewIdentifierLocation = isNewIdentifierDefinitionLocation(contextToken); if (previousToken !== contextToken) { ts.Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'."); } - // We need to find the node that will give us an appropriate scope to begin - // aggregating completion candidates. This is achieved in 'getScopeNode' - // by finding the first node that encompasses a position, accounting for whether a node - // is "complete" to decide whether a position belongs to the node. - // - // However, at the end of an identifier, we are interested in the scope of the identifier - // itself, but fall outside of the identifier. For instance: - // - // xyz => x$ - // - // the cursor is outside of both the 'x' and the arrow function 'xyz => x', - // so 'xyz' is not returned in our results. - // - // We define 'adjustedPosition' so that we may appropriately account for - // being at the end of an identifier. The intention is that if requesting completion - // at the end of an identifier, it should be effectively equivalent to requesting completion - // anywhere inside/at the beginning of the identifier. So in the previous case, the - // 'adjustedPosition' will work as if requesting completion in the following: - // - // xyz => $x - // - // If previousToken !== contextToken, then - // - 'contextToken' was adjusted to the token prior to 'previousToken' - // because we were at the end of an identifier. - // - 'previousToken' is defined. var adjustedPosition = previousToken !== contextToken ? previousToken.getStart() : position; var scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile; - /// TODO filter meaning based on the current context - var symbolMeanings = 793056 /* Type */ | 107455 /* Value */ | 1536 /* Namespace */ | 8388608 /* Alias */; + var symbolMeanings = 793056 | 107455 | 1536 | 8388608; symbols = typeChecker.getSymbolsInScope(scopeNode, symbolMeanings); } return true; } - /** - * Finds the first node that "embraces" the position, so that one may - * accurately aggregate locals from the closest containing scope. - */ function getScopeNode(initialToken, position, sourceFile) { var scope = initialToken; while (scope && !ts.positionBelongsToNode(scope, position, sourceFile)) { @@ -38044,10 +32170,8 @@ var ts; } function showCompletionsInImportsClause(node) { if (node) { - // import {| - // import {a,| - if (node.kind === 14 /* OpenBraceToken */ || node.kind === 23 /* CommaToken */) { - return node.parent.kind === 213 /* NamedImports */; + if (node.kind === 14 || node.kind === 23) { + return node.parent.kind === 213; } } return false; @@ -38056,39 +32180,38 @@ var ts; if (previousToken) { var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { - case 23 /* CommaToken */: - return containingNodeKind === 158 /* CallExpression */ // func( a, | - || containingNodeKind === 136 /* Constructor */ // constructor( a, | public, protected, private keywords are allowed here, so show completion - || containingNodeKind === 159 /* NewExpression */ // new C(a, | - || containingNodeKind === 154 /* ArrayLiteralExpression */ // [a, | - || containingNodeKind === 170 /* BinaryExpression */; // let x = (a, | - case 16 /* OpenParenToken */: - return containingNodeKind === 158 /* CallExpression */ // func( | - || containingNodeKind === 136 /* Constructor */ // constructor( | - || containingNodeKind === 159 /* NewExpression */ // new C(a| - || containingNodeKind === 162 /* ParenthesizedExpression */; // let x = (a| - case 18 /* OpenBracketToken */: - return containingNodeKind === 154 /* ArrayLiteralExpression */; // [ | - case 117 /* ModuleKeyword */: // module | - case 118 /* NamespaceKeyword */: + case 23: + return containingNodeKind === 158 + || containingNodeKind === 136 + || containingNodeKind === 159 + || containingNodeKind === 154 + || containingNodeKind === 170; + case 16: + return containingNodeKind === 158 + || containingNodeKind === 136 + || containingNodeKind === 159 + || containingNodeKind === 162; + case 18: + return containingNodeKind === 154; + case 117: + case 118: return true; - case 20 /* DotToken */: - return containingNodeKind === 206 /* ModuleDeclaration */; // module A.| - case 14 /* OpenBraceToken */: - return containingNodeKind === 202 /* ClassDeclaration */; // class A{ | - case 53 /* EqualsToken */: - return containingNodeKind === 199 /* VariableDeclaration */ // let x = a| - || containingNodeKind === 170 /* BinaryExpression */; // x = a| - case 11 /* TemplateHead */: - return containingNodeKind === 172 /* TemplateExpression */; // `aa ${| - case 12 /* TemplateMiddle */: - return containingNodeKind === 178 /* TemplateSpan */; // `aa ${10} dd ${| - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: - return containingNodeKind === 133 /* PropertyDeclaration */; // class A{ public | - } - // Previous token may have been a keyword that was converted to an identifier. + case 20: + return containingNodeKind === 206; + case 14: + return containingNodeKind === 202; + case 53: + return containingNodeKind === 199 + || containingNodeKind === 170; + case 11: + return containingNodeKind === 172; + case 12: + return containingNodeKind === 178; + case 108: + case 106: + case 107: + return containingNodeKind === 133; + } switch (previousToken.getText()) { case "public": case "protected": @@ -38099,11 +32222,9 @@ var ts; return false; } function isInStringOrRegularExpressionOrTemplateLiteral(previousToken) { - if (previousToken.kind === 8 /* StringLiteral */ - || previousToken.kind === 9 /* RegularExpressionLiteral */ + if (previousToken.kind === 8 + || previousToken.kind === 9 || ts.isTemplateLiteralKind(previousToken.kind)) { - // The position has to be either: 1. entirely within the token text, or - // 2. at the end position of an unterminated token. var start_3 = previousToken.getStart(); var end = previousToken.getEnd(); if (start_3 < position && position < end) { @@ -38120,9 +32241,9 @@ var ts; if (previousToken) { var parent_8 = previousToken.parent; switch (previousToken.kind) { - case 14 /* OpenBraceToken */: // let x = { | - case 23 /* CommaToken */: - if (parent_8 && parent_8.kind === 155 /* ObjectLiteralExpression */) { + case 14: + case 23: + if (parent_8 && parent_8.kind === 155) { return parent_8; } break; @@ -38132,16 +32253,16 @@ var ts; } function isFunction(kind) { switch (kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 163: + case 164: + case 201: + case 135: + case 134: + case 137: + case 138: + case 139: + case 140: + case 141: return true; } return false; @@ -38150,64 +32271,63 @@ var ts; if (previousToken) { var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { - case 23 /* CommaToken */: - return containingNodeKind === 199 /* VariableDeclaration */ || - containingNodeKind === 200 /* VariableDeclarationList */ || - containingNodeKind === 181 /* VariableStatement */ || - containingNodeKind === 205 /* EnumDeclaration */ || + case 23: + return containingNodeKind === 199 || + containingNodeKind === 200 || + containingNodeKind === 181 || + containingNodeKind === 205 || isFunction(containingNodeKind) || - containingNodeKind === 202 /* ClassDeclaration */ || - containingNodeKind === 201 /* FunctionDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || - containingNodeKind === 152 /* ArrayBindingPattern */ || - containingNodeKind === 151 /* ObjectBindingPattern */; // function func({ x, y| - case 20 /* DotToken */: - return containingNodeKind === 152 /* ArrayBindingPattern */; // var [.| - case 18 /* OpenBracketToken */: - return containingNodeKind === 152 /* ArrayBindingPattern */; // var [x| - case 16 /* OpenParenToken */: - return containingNodeKind === 224 /* CatchClause */ || + containingNodeKind === 202 || + containingNodeKind === 201 || + containingNodeKind === 203 || + containingNodeKind === 152 || + containingNodeKind === 151; + case 20: + return containingNodeKind === 152; + case 18: + return containingNodeKind === 152; + case 16: + return containingNodeKind === 224 || isFunction(containingNodeKind); - case 14 /* OpenBraceToken */: - return containingNodeKind === 205 /* EnumDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || - containingNodeKind === 146 /* TypeLiteral */ || - containingNodeKind === 151 /* ObjectBindingPattern */; // function func({ x| - case 22 /* SemicolonToken */: - return containingNodeKind === 132 /* PropertySignature */ && + case 14: + return containingNodeKind === 205 || + containingNodeKind === 203 || + containingNodeKind === 146 || + containingNodeKind === 151; + case 22: + return containingNodeKind === 132 && previousToken.parent && previousToken.parent.parent && - (previousToken.parent.parent.kind === 203 /* InterfaceDeclaration */ || - previousToken.parent.parent.kind === 146 /* TypeLiteral */); // let x : { a; | - case 24 /* LessThanToken */: - return containingNodeKind === 202 /* ClassDeclaration */ || - containingNodeKind === 201 /* FunctionDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || + (previousToken.parent.parent.kind === 203 || + previousToken.parent.parent.kind === 146); + case 24: + return containingNodeKind === 202 || + containingNodeKind === 201 || + containingNodeKind === 203 || isFunction(containingNodeKind); - case 109 /* StaticKeyword */: - return containingNodeKind === 133 /* PropertyDeclaration */; - case 21 /* DotDotDotToken */: - return containingNodeKind === 130 /* Parameter */ || - containingNodeKind === 136 /* Constructor */ || + case 109: + return containingNodeKind === 133; + case 21: + return containingNodeKind === 130 || + containingNodeKind === 136 || (previousToken.parent && previousToken.parent.parent && - previousToken.parent.parent.kind === 152 /* ArrayBindingPattern */); // var [ ...z| - case 108 /* PublicKeyword */: - case 106 /* PrivateKeyword */: - case 107 /* ProtectedKeyword */: - return containingNodeKind === 130 /* Parameter */; - case 69 /* ClassKeyword */: - case 77 /* EnumKeyword */: - case 103 /* InterfaceKeyword */: - case 83 /* FunctionKeyword */: - case 98 /* VarKeyword */: - case 116 /* GetKeyword */: - case 121 /* SetKeyword */: - case 85 /* ImportKeyword */: - case 104 /* LetKeyword */: - case 70 /* ConstKeyword */: - case 110 /* YieldKeyword */: + previousToken.parent.parent.kind === 152); + case 108: + case 106: + case 107: + return containingNodeKind === 130; + case 69: + case 77: + case 103: + case 83: + case 98: + case 116: + case 121: + case 85: + case 104: + case 70: + case 110: return true; } - // Previous token may have been a keyword that was converted to an identifier. switch (previousToken.getText()) { case "class": case "interface": @@ -38224,7 +32344,7 @@ var ts; return false; } function isRightOfIllegalDot(previousToken) { - if (previousToken && previousToken.kind === 7 /* NumericLiteral */) { + if (previousToken && previousToken.kind === 7) { var text = previousToken.getFullText(); return text.charAt(text.length - 1) === "."; } @@ -38236,7 +32356,7 @@ var ts; return exports; } if (importDeclaration.importClause.namedBindings && - importDeclaration.importClause.namedBindings.kind === 213 /* NamedImports */) { + importDeclaration.importClause.namedBindings.kind === 213) { ts.forEach(importDeclaration.importClause.namedBindings.elements, function (el) { var name = el.propertyName || el.name; exisingImports[name.text] = true; @@ -38253,15 +32373,12 @@ var ts; } var existingMemberNames = {}; ts.forEach(existingMembers, function (m) { - if (m.kind !== 225 /* PropertyAssignment */ && m.kind !== 226 /* ShorthandPropertyAssignment */) { - // Ignore omitted expressions for missing members in the object literal + if (m.kind !== 225 && m.kind !== 226) { return; } if (m.getStart() <= position && position <= m.getEnd()) { - // If this is the current item we are editing right now, do not filter it out return; } - // TODO(jfreeman): Account for computed property name existingMemberNames[m.name.text] = true; }); var filteredMembers = []; @@ -38291,7 +32408,6 @@ var ts; } entries = getCompletionEntriesFromSymbols(symbols); } - // Add keywords if this is not a member completion list if (!isMemberCompletion) { ts.addRange(entries, keywordCompletions); } @@ -38322,20 +32438,10 @@ var ts; return entries; } function createCompletionEntry(symbol, location) { - // Try to get a valid display name for this symbol, if we could not find one, then ignore it. - // We would like to only show things that can be added after a dot, so for instance numeric properties can - // not be accessed with a dot (a.1 <- invalid) var displayName = getCompletionEntryDisplayNameForSymbol(symbol, program.getCompilerOptions().target, true); if (!displayName) { return undefined; } - // TODO(drosen): Right now we just permit *all* semantic meanings when calling - // 'getSymbolKind' which is permissible given that it is backwards compatible; but - // really we should consider passing the meaning for the node so that we don't report - // that a suggestion for a value is an interface. We COULD also just do what - // 'getSymbolModifiers' does, which is to use the first declaration. - // Use a 'sortText' of 0' so that all symbol completion entries come before any other - // entries (like JavaScript identifier entries). return { name: displayName, kind: getSymbolKind(symbol, location), @@ -38366,18 +32472,13 @@ var ts; } function getCompletionEntryDetails(fileName, position, entryName) { synchronizeHostData(); - // Compute all the completion symbols again. var completionData = getCompletionData(fileName, position); if (completionData) { var symbols = completionData.symbols, location_2 = completionData.location; - // Find the symbol with the matching entry name. var target = program.getCompilerOptions().target; - // We don't need to perform character checks here because we're only comparing the - // name against 'entryName' (which is known to be good), not building a new - // completion entry. var symbol = ts.forEach(symbols, function (s) { return getCompletionEntryDisplayNameForSymbol(s, target, false) === entryName ? s : undefined; }); if (symbol) { - var displayPartsDocumentationsAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getValidSourceFile(fileName), location_2, location_2, 7 /* All */); + var displayPartsDocumentationsAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getValidSourceFile(fileName), location_2, location_2, 7); return { name: entryName, kind: displayPartsDocumentationsAndSymbolKind.symbolKind, @@ -38387,7 +32488,6 @@ var ts; }; } } - // Didn't find a symbol with this name. See if we can find a keyword instead. var keywordCompletion = ts.forEach(keywordCompletions, function (c) { return c.name === entryName; }); if (keywordCompletion) { return { @@ -38400,28 +32500,27 @@ var ts; } return undefined; } - // TODO(drosen): use contextual SemanticMeaning. function getSymbolKind(symbol, location) { var flags = symbol.getFlags(); - if (flags & 32 /* Class */) + if (flags & 32) return ScriptElementKind.classElement; - if (flags & 384 /* Enum */) + if (flags & 384) return ScriptElementKind.enumElement; - if (flags & 524288 /* TypeAlias */) + if (flags & 524288) return ScriptElementKind.typeElement; - if (flags & 64 /* Interface */) + if (flags & 64) return ScriptElementKind.interfaceElement; - if (flags & 262144 /* TypeParameter */) + if (flags & 262144) return ScriptElementKind.typeParameterElement; var result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, flags, location); if (result === ScriptElementKind.unknown) { - if (flags & 262144 /* TypeParameter */) + if (flags & 262144) return ScriptElementKind.typeParameterElement; - if (flags & 8 /* EnumMember */) + if (flags & 8) return ScriptElementKind.variableElement; - if (flags & 8388608 /* Alias */) + if (flags & 8388608) return ScriptElementKind.alias; - if (flags & 1536 /* Module */) + if (flags & 1536) return ScriptElementKind.moduleElement; } return result; @@ -38434,7 +32533,7 @@ var ts; if (typeChecker.isArgumentsSymbol(symbol)) { return ScriptElementKind.localVariableElement; } - if (flags & 3 /* Variable */) { + if (flags & 3) { if (ts.isFirstDeclarationOfSymbolParameter(symbol)) { return ScriptElementKind.parameterElement; } @@ -38446,29 +32545,26 @@ var ts; } return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement; } - if (flags & 16 /* Function */) + if (flags & 16) return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localFunctionElement : ScriptElementKind.functionElement; - if (flags & 32768 /* GetAccessor */) + if (flags & 32768) return ScriptElementKind.memberGetAccessorElement; - if (flags & 65536 /* SetAccessor */) + if (flags & 65536) return ScriptElementKind.memberSetAccessorElement; - if (flags & 8192 /* Method */) + if (flags & 8192) return ScriptElementKind.memberFunctionElement; - if (flags & 16384 /* Constructor */) + if (flags & 16384) return ScriptElementKind.constructorImplementationElement; - if (flags & 4 /* Property */) { - if (flags & 268435456 /* UnionProperty */) { - // If union property is result of union of non method (property/accessors/variables), it is labeled as property + if (flags & 4) { + if (flags & 268435456) { var unionPropertyKind = ts.forEach(typeChecker.getRootSymbols(symbol), function (rootSymbol) { var rootSymbolFlags = rootSymbol.getFlags(); - if (rootSymbolFlags & (98308 /* PropertyOrAccessor */ | 3 /* Variable */)) { + if (rootSymbolFlags & (98308 | 3)) { return ScriptElementKind.memberVariableElement; } - ts.Debug.assert(!!(rootSymbolFlags & 8192 /* Method */)); + ts.Debug.assert(!!(rootSymbolFlags & 8192)); }); if (!unionPropertyKind) { - // If this was union of all methods, - //make sure it has call signatures before we can label it as method var typeOfUnionProperty = typeChecker.getTypeOfSymbolAtLocation(symbol, location); if (typeOfUnionProperty.getCallSignatures().length) { return ScriptElementKind.memberFunctionElement; @@ -38481,28 +32577,11 @@ var ts; } return ScriptElementKind.unknown; } - function getTypeKind(type) { - var flags = type.getFlags(); - if (flags & 128 /* Enum */) - return ScriptElementKind.enumElement; - if (flags & 1024 /* Class */) - return ScriptElementKind.classElement; - if (flags & 2048 /* Interface */) - return ScriptElementKind.interfaceElement; - if (flags & 512 /* TypeParameter */) - return ScriptElementKind.typeParameterElement; - if (flags & 1048703 /* Intrinsic */) - return ScriptElementKind.primitiveType; - if (flags & 256 /* StringLiteral */) - return ScriptElementKind.primitiveType; - return ScriptElementKind.unknown; - } function getSymbolModifiers(symbol) { return symbol && symbol.declarations && symbol.declarations.length > 0 ? ts.getNodeModifiers(symbol.declarations[0]) : ScriptElementKindModifier.none; } - // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location function getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, sourceFile, enclosingDeclaration, location, semanticMeaning) { if (semanticMeaning === void 0) { semanticMeaning = getMeaningFromLocation(location); } var typeChecker = program.getTypeChecker(); @@ -38512,25 +32591,21 @@ var ts; var symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, symbolFlags, location); var hasAddedSymbolInfo; var type; - // Class at constructor site need to be shown as constructor apart from property,method, vars - if (symbolKind !== ScriptElementKind.unknown || symbolFlags & 32 /* Class */ || symbolFlags & 8388608 /* Alias */) { - // If it is accessor they are allowed only if location is at name of the accessor + if (symbolKind !== ScriptElementKind.unknown || symbolFlags & 32 || symbolFlags & 8388608) { if (symbolKind === ScriptElementKind.memberGetAccessorElement || symbolKind === ScriptElementKind.memberSetAccessorElement) { symbolKind = ScriptElementKind.memberVariableElement; } var signature; type = typeChecker.getTypeOfSymbolAtLocation(symbol, location); if (type) { - if (location.parent && location.parent.kind === 156 /* PropertyAccessExpression */) { + if (location.parent && location.parent.kind === 156) { var right = location.parent.name; - // Either the location is on the right of a property access, or on the left and the right is missing if (right === location || (right && right.getFullWidth() === 0)) { location = location.parent; } } - // try get the call/construct signature from the type if it matches var callExpression; - if (location.kind === 158 /* CallExpression */ || location.kind === 159 /* NewExpression */) { + if (location.kind === 158 || location.kind === 159) { callExpression = location; } else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) { @@ -38540,27 +32615,24 @@ var ts; var candidateSignatures = []; signature = typeChecker.getResolvedSignature(callExpression, candidateSignatures); if (!signature && candidateSignatures.length) { - // Use the first candidate: signature = candidateSignatures[0]; } - var useConstructSignatures = callExpression.kind === 159 /* NewExpression */ || callExpression.expression.kind === 91 /* SuperKeyword */; + var useConstructSignatures = callExpression.kind === 159 || callExpression.expression.kind === 91; var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); if (!ts.contains(allSignatures, signature.target || signature)) { - // Get the first signature if there signature = allSignatures.length ? allSignatures[0] : undefined; } if (signature) { - if (useConstructSignatures && (symbolFlags & 32 /* Class */)) { - // Constructor + if (useConstructSignatures && (symbolFlags & 32)) { symbolKind = ScriptElementKind.constructorImplementationElement; addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); } - else if (symbolFlags & 8388608 /* Alias */) { + else if (symbolFlags & 8388608) { symbolKind = ScriptElementKind.alias; pushTypePart(symbolKind); displayParts.push(ts.spacePart()); if (useConstructSignatures) { - displayParts.push(ts.keywordPart(88 /* NewKeyword */)); + displayParts.push(ts.keywordPart(88)); displayParts.push(ts.spacePart()); } addFullSymbolName(symbol); @@ -38575,156 +32647,149 @@ var ts; case ScriptElementKind.letElement: case ScriptElementKind.parameterElement: case ScriptElementKind.localVariableElement: - // If it is call or construct signature of lambda's write type name - displayParts.push(ts.punctuationPart(51 /* ColonToken */)); + displayParts.push(ts.punctuationPart(51)); displayParts.push(ts.spacePart()); if (useConstructSignatures) { - displayParts.push(ts.keywordPart(88 /* NewKeyword */)); + displayParts.push(ts.keywordPart(88)); displayParts.push(ts.spacePart()); } - if (!(type.flags & 32768 /* Anonymous */)) { - displayParts.push.apply(displayParts, ts.symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, undefined, 1 /* WriteTypeParametersOrArguments */)); + if (!(type.flags & 32768)) { + displayParts.push.apply(displayParts, ts.symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, undefined, 1)); } - addSignatureDisplayParts(signature, allSignatures, 8 /* WriteArrowStyleSignature */); + addSignatureDisplayParts(signature, allSignatures, 8); break; default: - // Just signature addSignatureDisplayParts(signature, allSignatures); } hasAddedSymbolInfo = true; } } - else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304 /* Accessor */)) || - (location.kind === 114 /* ConstructorKeyword */ && location.parent.kind === 136 /* Constructor */)) { - // get the signature from the declaration and write it + else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304)) || + (location.kind === 114 && location.parent.kind === 136)) { var functionDeclaration = location.parent; - var allSignatures = functionDeclaration.kind === 136 /* Constructor */ ? type.getConstructSignatures() : type.getCallSignatures(); + var allSignatures = functionDeclaration.kind === 136 ? type.getConstructSignatures() : type.getCallSignatures(); if (!typeChecker.isImplementationOfOverload(functionDeclaration)) { signature = typeChecker.getSignatureFromDeclaration(functionDeclaration); } else { signature = allSignatures[0]; } - if (functionDeclaration.kind === 136 /* Constructor */) { - // show (constructor) Type(...) signature + if (functionDeclaration.kind === 136) { symbolKind = ScriptElementKind.constructorImplementationElement; addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); } else { - // (function/method) symbol(..signature) - addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 139 /* CallSignature */ && - !(type.symbol.flags & 2048 /* TypeLiteral */ || type.symbol.flags & 4096 /* ObjectLiteral */) ? type.symbol : symbol, symbolKind); + addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 139 && + !(type.symbol.flags & 2048 || type.symbol.flags & 4096) ? type.symbol : symbol, symbolKind); } addSignatureDisplayParts(signature, allSignatures); hasAddedSymbolInfo = true; } } } - if (symbolFlags & 32 /* Class */ && !hasAddedSymbolInfo) { - displayParts.push(ts.keywordPart(69 /* ClassKeyword */)); + if (symbolFlags & 32 && !hasAddedSymbolInfo) { + displayParts.push(ts.keywordPart(69)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); writeTypeParametersOfSymbol(symbol, sourceFile); } - if ((symbolFlags & 64 /* Interface */) && (semanticMeaning & 2 /* Type */)) { + if ((symbolFlags & 64) && (semanticMeaning & 2)) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(103 /* InterfaceKeyword */)); + displayParts.push(ts.keywordPart(103)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); writeTypeParametersOfSymbol(symbol, sourceFile); } - if (symbolFlags & 524288 /* TypeAlias */) { + if (symbolFlags & 524288) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(124 /* TypeKeyword */)); + displayParts.push(ts.keywordPart(124)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); displayParts.push(ts.spacePart()); - displayParts.push(ts.operatorPart(53 /* EqualsToken */)); + displayParts.push(ts.operatorPart(53)); displayParts.push(ts.spacePart()); displayParts.push.apply(displayParts, ts.typeToDisplayParts(typeChecker, typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration)); } - if (symbolFlags & 384 /* Enum */) { + if (symbolFlags & 384) { addNewLineIfDisplayPartsExist(); if (ts.forEach(symbol.declarations, ts.isConstEnumDeclaration)) { - displayParts.push(ts.keywordPart(70 /* ConstKeyword */)); + displayParts.push(ts.keywordPart(70)); displayParts.push(ts.spacePart()); } - displayParts.push(ts.keywordPart(77 /* EnumKeyword */)); + displayParts.push(ts.keywordPart(77)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); } - if (symbolFlags & 1536 /* Module */) { + if (symbolFlags & 1536) { addNewLineIfDisplayPartsExist(); - var declaration = ts.getDeclarationOfKind(symbol, 206 /* ModuleDeclaration */); - var isNamespace = declaration && declaration.name && declaration.name.kind === 65 /* Identifier */; - displayParts.push(ts.keywordPart(isNamespace ? 118 /* NamespaceKeyword */ : 117 /* ModuleKeyword */)); + var declaration = ts.getDeclarationOfKind(symbol, 206); + var isNamespace = declaration && declaration.name && declaration.name.kind === 65; + displayParts.push(ts.keywordPart(isNamespace ? 118 : 117)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); } - if ((symbolFlags & 262144 /* TypeParameter */) && (semanticMeaning & 2 /* Type */)) { + if ((symbolFlags & 262144) && (semanticMeaning & 2)) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.punctuationPart(16 /* OpenParenToken */)); + displayParts.push(ts.punctuationPart(16)); displayParts.push(ts.textPart("type parameter")); - displayParts.push(ts.punctuationPart(17 /* CloseParenToken */)); + displayParts.push(ts.punctuationPart(17)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); displayParts.push(ts.spacePart()); - displayParts.push(ts.keywordPart(86 /* InKeyword */)); + displayParts.push(ts.keywordPart(86)); displayParts.push(ts.spacePart()); if (symbol.parent) { - // Class/Interface type parameter addFullSymbolName(symbol.parent, enclosingDeclaration); writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration); } else { - // Method/function type parameter - var signatureDeclaration = ts.getDeclarationOfKind(symbol, 129 /* TypeParameter */).parent; + var signatureDeclaration = ts.getDeclarationOfKind(symbol, 129).parent; var signature = typeChecker.getSignatureFromDeclaration(signatureDeclaration); - if (signatureDeclaration.kind === 140 /* ConstructSignature */) { - displayParts.push(ts.keywordPart(88 /* NewKeyword */)); + if (signatureDeclaration.kind === 140) { + displayParts.push(ts.keywordPart(88)); displayParts.push(ts.spacePart()); } - else if (signatureDeclaration.kind !== 139 /* CallSignature */ && signatureDeclaration.name) { + else if (signatureDeclaration.kind !== 139 && signatureDeclaration.name) { addFullSymbolName(signatureDeclaration.symbol); } - displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeChecker, signature, sourceFile, 32 /* WriteTypeArgumentsOfSignature */)); + displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeChecker, signature, sourceFile, 32)); } } - if (symbolFlags & 8 /* EnumMember */) { + if (symbolFlags & 8) { addPrefixForAnyFunctionOrVar(symbol, "enum member"); var declaration = symbol.declarations[0]; - if (declaration.kind === 227 /* EnumMember */) { + if (declaration.kind === 227) { var constantValue = typeChecker.getConstantValue(declaration); if (constantValue !== undefined) { displayParts.push(ts.spacePart()); - displayParts.push(ts.operatorPart(53 /* EqualsToken */)); + displayParts.push(ts.operatorPart(53)); displayParts.push(ts.spacePart()); displayParts.push(ts.displayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral)); } } } - if (symbolFlags & 8388608 /* Alias */) { + if (symbolFlags & 8388608) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(85 /* ImportKeyword */)); + displayParts.push(ts.keywordPart(85)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 209 /* ImportEqualsDeclaration */) { + if (declaration.kind === 209) { var importEqualsDeclaration = declaration; if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { displayParts.push(ts.spacePart()); - displayParts.push(ts.operatorPart(53 /* EqualsToken */)); + displayParts.push(ts.operatorPart(53)); displayParts.push(ts.spacePart()); - displayParts.push(ts.keywordPart(119 /* RequireKeyword */)); - displayParts.push(ts.punctuationPart(16 /* OpenParenToken */)); + displayParts.push(ts.keywordPart(119)); + displayParts.push(ts.punctuationPart(16)); displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), SymbolDisplayPartKind.stringLiteral)); - displayParts.push(ts.punctuationPart(17 /* CloseParenToken */)); + displayParts.push(ts.punctuationPart(17)); } else { var internalAliasSymbol = typeChecker.getSymbolAtLocation(importEqualsDeclaration.moduleReference); if (internalAliasSymbol) { displayParts.push(ts.spacePart()); - displayParts.push(ts.operatorPart(53 /* EqualsToken */)); + displayParts.push(ts.operatorPart(53)); displayParts.push(ts.spacePart()); addFullSymbolName(internalAliasSymbol, enclosingDeclaration); } @@ -38737,14 +32802,12 @@ var ts; if (symbolKind !== ScriptElementKind.unknown) { if (type) { addPrefixForAnyFunctionOrVar(symbol, symbolKind); - // For properties, variables and local vars: show the type if (symbolKind === ScriptElementKind.memberVariableElement || - symbolFlags & 3 /* Variable */ || + symbolFlags & 3 || symbolKind === ScriptElementKind.localVariableElement) { - displayParts.push(ts.punctuationPart(51 /* ColonToken */)); + displayParts.push(ts.punctuationPart(51)); displayParts.push(ts.spacePart()); - // If the type is type parameter, format it specially - if (type.symbol && type.symbol.flags & 262144 /* TypeParameter */) { + if (type.symbol && type.symbol.flags & 262144) { var typeParameterParts = ts.mapToDisplayParts(function (writer) { typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplay(type, writer, enclosingDeclaration); }); @@ -38754,11 +32817,11 @@ var ts; displayParts.push.apply(displayParts, ts.typeToDisplayParts(typeChecker, type, enclosingDeclaration)); } } - else if (symbolFlags & 16 /* Function */ || - symbolFlags & 8192 /* Method */ || - symbolFlags & 16384 /* Constructor */ || - symbolFlags & 131072 /* Signature */ || - symbolFlags & 98304 /* Accessor */ || + else if (symbolFlags & 16 || + symbolFlags & 8192 || + symbolFlags & 16384 || + symbolFlags & 131072 || + symbolFlags & 98304 || symbolKind === ScriptElementKind.memberFunctionElement) { var allSignatures = type.getCallSignatures(); addSignatureDisplayParts(allSignatures[0], allSignatures); @@ -38779,7 +32842,7 @@ var ts; } } function addFullSymbolName(symbol, enclosingDeclaration) { - var fullSymbolDisplayParts = ts.symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration || sourceFile, undefined, 1 /* WriteTypeParametersOrArguments */ | 2 /* UseOnlyExternalAliasing */); + var fullSymbolDisplayParts = ts.symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration || sourceFile, undefined, 1 | 2); displayParts.push.apply(displayParts, fullSymbolDisplayParts); } function addPrefixForAnyFunctionOrVar(symbol, symbolKind) { @@ -38800,22 +32863,22 @@ var ts; displayParts.push(ts.textOrKeywordPart(symbolKind)); return; default: - displayParts.push(ts.punctuationPart(16 /* OpenParenToken */)); + displayParts.push(ts.punctuationPart(16)); displayParts.push(ts.textOrKeywordPart(symbolKind)); - displayParts.push(ts.punctuationPart(17 /* CloseParenToken */)); + displayParts.push(ts.punctuationPart(17)); return; } } function addSignatureDisplayParts(signature, allSignatures, flags) { - displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | 32 /* WriteTypeArgumentsOfSignature */)); + displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | 32)); if (allSignatures.length > 1) { displayParts.push(ts.spacePart()); - displayParts.push(ts.punctuationPart(16 /* OpenParenToken */)); - displayParts.push(ts.operatorPart(33 /* PlusToken */)); + displayParts.push(ts.punctuationPart(16)); + displayParts.push(ts.operatorPart(33)); displayParts.push(ts.displayPart((allSignatures.length - 1).toString(), SymbolDisplayPartKind.numericLiteral)); displayParts.push(ts.spacePart()); displayParts.push(ts.textPart(allSignatures.length === 2 ? "overload" : "overloads")); - displayParts.push(ts.punctuationPart(17 /* CloseParenToken */)); + displayParts.push(ts.punctuationPart(17)); } documentation = signature.getDocumentationComment(); } @@ -38839,14 +32902,12 @@ var ts; var typeChecker = program.getTypeChecker(); var symbol = typeChecker.getSymbolAtLocation(node); if (!symbol) { - // Try getting just type at this position and show switch (node.kind) { - case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: - case 93 /* ThisKeyword */: - case 91 /* SuperKeyword */: - // For the identifiers/this/super etc get the type at position + case 65: + case 156: + case 127: + case 93: + case 91: var type = typeChecker.getTypeAtLocation(node); if (type) { return { @@ -38879,7 +32940,59 @@ var ts; containerName: containerName }; } - /// Goto definition + function getDefinitionFromSymbol(symbol, node) { + var typeChecker = program.getTypeChecker(); + var result = []; + var declarations = symbol.getDeclarations(); + var symbolName = typeChecker.symbolToString(symbol); + var symbolKind = getSymbolKind(symbol, node); + var containerSymbol = symbol.parent; + var containerName = containerSymbol ? typeChecker.symbolToString(containerSymbol, node) : ""; + if (!tryAddConstructSignature(symbol, node, symbolKind, symbolName, containerName, result) && + !tryAddCallSignature(symbol, node, symbolKind, symbolName, containerName, result)) { + ts.forEach(declarations, function (declaration) { + result.push(createDefinitionInfo(declaration, symbolKind, symbolName, containerName)); + }); + } + return result; + function tryAddConstructSignature(symbol, location, symbolKind, symbolName, containerName, result) { + if (isNewExpressionTarget(location) || location.kind === 114) { + if (symbol.flags & 32) { + var classDeclaration = symbol.getDeclarations()[0]; + ts.Debug.assert(classDeclaration && classDeclaration.kind === 202); + return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); + } + } + return false; + } + function tryAddCallSignature(symbol, location, symbolKind, symbolName, containerName, result) { + if (isCallExpressionTarget(location) || isNewExpressionTarget(location) || isNameOfFunctionDeclaration(location)) { + return tryAddSignature(symbol.declarations, false, symbolKind, symbolName, containerName, result); + } + return false; + } + function tryAddSignature(signatureDeclarations, selectConstructors, symbolKind, symbolName, containerName, result) { + var declarations = []; + var definition; + ts.forEach(signatureDeclarations, function (d) { + if ((selectConstructors && d.kind === 136) || + (!selectConstructors && (d.kind === 201 || d.kind === 135 || d.kind === 134))) { + declarations.push(d); + if (d.body) + definition = d; + } + }); + if (definition) { + result.push(createDefinitionInfo(definition, symbolKind, symbolName, containerName)); + return true; + } + else if (declarations.length) { + result.push(createDefinitionInfo(ts.lastOrUndefined(declarations), symbolKind, symbolName, containerName)); + return true; + } + return false; + } + } function getDefinitionAtPosition(fileName, position) { synchronizeHostData(); var sourceFile = getValidSourceFile(fileName); @@ -38887,13 +33000,11 @@ var ts; if (!node) { return undefined; } - // Labels if (isJumpStatementTarget(node)) { var labelName = node.text; var label = getTargetLabel(node.parent, node.text); return label ? [createDefinitionInfo(label, ScriptElementKind.label, labelName, undefined)] : undefined; } - /// Triple slash reference comments var comment = ts.forEach(sourceFile.referencedFiles, function (r) { return (r.pos <= position && position < r.end) ? r : undefined; }); if (comment) { var referenceFile = ts.tryResolveScriptReference(program, sourceFile, comment); @@ -38911,27 +33022,16 @@ var ts; } var typeChecker = program.getTypeChecker(); var symbol = typeChecker.getSymbolAtLocation(node); - // Could not find a symbol e.g. node is string or number keyword, - // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol if (!symbol) { return undefined; } - // If this is an alias, and the request came at the declaration location - // get the aliased symbol instead. This allows for goto def on an import e.g. - // import {A, B} from "mod"; - // to jump to the implementation directly. - if (symbol.flags & 8388608 /* Alias */) { + if (symbol.flags & 8388608) { var declaration = symbol.declarations[0]; - if (node.kind === 65 /* Identifier */ && node.parent === declaration) { + if (node.kind === 65 && node.parent === declaration) { symbol = typeChecker.getAliasedSymbol(symbol); } } - // Because name in short-hand property assignment has two different meanings: property name and property value, - // using go-to-definition at such position should go to the variable declaration of the property value rather than - // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition - // is performed at the location of property access, we would like to go to definition of the property in the short-hand - // assignment. This case and others are handled by the following code. - if (node.parent.kind === 226 /* ShorthandPropertyAssignment */) { + if (node.parent.kind === 226) { var shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); if (!shorthandSymbol) { return []; @@ -38942,66 +33042,42 @@ var ts; var shorthandContainerName = typeChecker.symbolToString(symbol.parent, node); return ts.map(shorthandDeclarations, function (declaration) { return createDefinitionInfo(declaration, shorthandSymbolKind, shorthandSymbolName, shorthandContainerName); }); } - var result = []; - var declarations = symbol.getDeclarations(); - var symbolName = typeChecker.symbolToString(symbol); // Do not get scoped name, just the name of the symbol - var symbolKind = getSymbolKind(symbol, node); - var containerSymbol = symbol.parent; - var containerName = containerSymbol ? typeChecker.symbolToString(containerSymbol, node) : ""; - if (!tryAddConstructSignature(symbol, node, symbolKind, symbolName, containerName, result) && - !tryAddCallSignature(symbol, node, symbolKind, symbolName, containerName, result)) { - // Just add all the declarations. - ts.forEach(declarations, function (declaration) { - result.push(createDefinitionInfo(declaration, symbolKind, symbolName, containerName)); - }); + return getDefinitionFromSymbol(symbol, node); + } + function getTypeDefinitionAtPosition(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, position); + if (!node) { + return undefined; } - return result; - function tryAddConstructSignature(symbol, location, symbolKind, symbolName, containerName, result) { - // Applicable only if we are in a new expression, or we are on a constructor declaration - // and in either case the symbol has a construct signature definition, i.e. class - if (isNewExpressionTarget(location) || location.kind === 114 /* ConstructorKeyword */) { - if (symbol.flags & 32 /* Class */) { - var classDeclaration = symbol.getDeclarations()[0]; - ts.Debug.assert(classDeclaration && classDeclaration.kind === 202 /* ClassDeclaration */); - return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); - } - } - return false; + var typeChecker = program.getTypeChecker(); + var symbol = typeChecker.getSymbolAtLocation(node); + if (!symbol) { + return undefined; } - function tryAddCallSignature(symbol, location, symbolKind, symbolName, containerName, result) { - if (isCallExpressionTarget(location) || isNewExpressionTarget(location) || isNameOfFunctionDeclaration(location)) { - return tryAddSignature(symbol.declarations, false, symbolKind, symbolName, containerName, result); - } - return false; + var type = typeChecker.getTypeOfSymbolAtLocation(symbol, node); + if (!type) { + return undefined; } - function tryAddSignature(signatureDeclarations, selectConstructors, symbolKind, symbolName, containerName, result) { - var declarations = []; - var definition; - ts.forEach(signatureDeclarations, function (d) { - if ((selectConstructors && d.kind === 136 /* Constructor */) || - (!selectConstructors && (d.kind === 201 /* FunctionDeclaration */ || d.kind === 135 /* MethodDeclaration */ || d.kind === 134 /* MethodSignature */))) { - declarations.push(d); - if (d.body) - definition = d; + if (type.flags & 16384) { + var result = []; + ts.forEach(type.types, function (t) { + if (t.symbol) { + result.push.apply(result, getDefinitionFromSymbol(t.symbol, node)); } }); - if (definition) { - result.push(createDefinitionInfo(definition, symbolKind, symbolName, containerName)); - return true; - } - else if (declarations.length) { - result.push(createDefinitionInfo(declarations[declarations.length - 1], symbolKind, symbolName, containerName)); - return true; - } - return false; + return result; + } + if (!type.symbol) { + return undefined; } + return getDefinitionFromSymbol(type.symbol, node); } function getOccurrencesAtPosition(fileName, position) { var results = getOccurrencesAtPositionCore(fileName, position); if (results) { var sourceFile = getCanonicalFileName(ts.normalizeSlashes(fileName)); - // Get occurrences only supports reporting occurrences for the file queried. So - // filter down to that list. results = ts.filter(results, function (r) { return getCanonicalFileName(ts.normalizeSlashes(r.fileName)) === sourceFile; }); } return results; @@ -39026,9 +33102,9 @@ var ts; }; } function getSemanticDocumentHighlights(node) { - if (node.kind === 65 /* Identifier */ || - node.kind === 93 /* ThisKeyword */ || - node.kind === 91 /* SuperKeyword */ || + if (node.kind === 65 || + node.kind === 93 || + node.kind === 91 || isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) { var referencedSymbols = getReferencedSymbolsForNodes(node, sourceFilesToSearch, false, false); @@ -39068,113 +33144,105 @@ var ts; return undefined; } return [{ fileName: fileName, highlightSpans: highlightSpans }]; - // returns true if 'node' is defined and has a matching 'kind'. function hasKind(node, kind) { return node !== undefined && node.kind === kind; } - // Null-propagating 'parent' function. function parent(node) { return node && node.parent; } function getHighlightSpans(node) { if (node) { switch (node.kind) { - case 84 /* IfKeyword */: - case 76 /* ElseKeyword */: - if (hasKind(node.parent, 184 /* IfStatement */)) { + case 84: + case 76: + if (hasKind(node.parent, 184)) { return getIfElseOccurrences(node.parent); } break; - case 90 /* ReturnKeyword */: - if (hasKind(node.parent, 192 /* ReturnStatement */)) { + case 90: + if (hasKind(node.parent, 192)) { return getReturnOccurrences(node.parent); } break; - case 94 /* ThrowKeyword */: - if (hasKind(node.parent, 196 /* ThrowStatement */)) { + case 94: + if (hasKind(node.parent, 196)) { return getThrowOccurrences(node.parent); } break; - case 68 /* CatchKeyword */: - if (hasKind(parent(parent(node)), 197 /* TryStatement */)) { + case 68: + if (hasKind(parent(parent(node)), 197)) { return getTryCatchFinallyOccurrences(node.parent.parent); } break; - case 96 /* TryKeyword */: - case 81 /* FinallyKeyword */: - if (hasKind(parent(node), 197 /* TryStatement */)) { + case 96: + case 81: + if (hasKind(parent(node), 197)) { return getTryCatchFinallyOccurrences(node.parent); } break; - case 92 /* SwitchKeyword */: - if (hasKind(node.parent, 194 /* SwitchStatement */)) { + case 92: + if (hasKind(node.parent, 194)) { return getSwitchCaseDefaultOccurrences(node.parent); } break; - case 67 /* CaseKeyword */: - case 73 /* DefaultKeyword */: - if (hasKind(parent(parent(parent(node))), 194 /* SwitchStatement */)) { + case 67: + case 73: + if (hasKind(parent(parent(parent(node))), 194)) { return getSwitchCaseDefaultOccurrences(node.parent.parent.parent); } break; - case 66 /* BreakKeyword */: - case 71 /* ContinueKeyword */: - if (hasKind(node.parent, 191 /* BreakStatement */) || hasKind(node.parent, 190 /* ContinueStatement */)) { + case 66: + case 71: + if (hasKind(node.parent, 191) || hasKind(node.parent, 190)) { return getBreakOrContinueStatementOccurences(node.parent); } break; - case 82 /* ForKeyword */: - if (hasKind(node.parent, 187 /* ForStatement */) || - hasKind(node.parent, 188 /* ForInStatement */) || - hasKind(node.parent, 189 /* ForOfStatement */)) { + case 82: + if (hasKind(node.parent, 187) || + hasKind(node.parent, 188) || + hasKind(node.parent, 189)) { return getLoopBreakContinueOccurrences(node.parent); } break; - case 100 /* WhileKeyword */: - case 75 /* DoKeyword */: - if (hasKind(node.parent, 186 /* WhileStatement */) || hasKind(node.parent, 185 /* DoStatement */)) { + case 100: + case 75: + if (hasKind(node.parent, 186) || hasKind(node.parent, 185)) { return getLoopBreakContinueOccurrences(node.parent); } break; - case 114 /* ConstructorKeyword */: - if (hasKind(node.parent, 136 /* Constructor */)) { + case 114: + if (hasKind(node.parent, 136)) { return getConstructorOccurrences(node.parent); } break; - case 116 /* GetKeyword */: - case 121 /* SetKeyword */: - if (hasKind(node.parent, 137 /* GetAccessor */) || hasKind(node.parent, 138 /* SetAccessor */)) { + case 116: + case 121: + if (hasKind(node.parent, 137) || hasKind(node.parent, 138)) { return getGetAndSetOccurrences(node.parent); } default: if (ts.isModifier(node.kind) && node.parent && - (ts.isDeclaration(node.parent) || node.parent.kind === 181 /* VariableStatement */)) { + (ts.isDeclaration(node.parent) || node.parent.kind === 181)) { return getModifierOccurrences(node.kind, node.parent); } } } return undefined; } - /** - * Aggregates all throw-statements within this node *without* crossing - * into function boundaries and try-blocks with catch-clauses. - */ function aggregateOwnedThrowStatements(node) { var statementAccumulator = []; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 196 /* ThrowStatement */) { + if (node.kind === 196) { statementAccumulator.push(node); } - else if (node.kind === 197 /* TryStatement */) { + else if (node.kind === 197) { var tryStatement = node; if (tryStatement.catchClause) { aggregate(tryStatement.catchClause); } else { - // Exceptions thrown within a try block lacking a catch clause - // are "owned" in the current context. aggregate(tryStatement.tryBlock); } if (tryStatement.finallyBlock) { @@ -39187,21 +33255,14 @@ var ts; } ; } - /** - * For lack of a better name, this function takes a throw statement and returns the - * nearest ancestor that is a try-block (whose try statement has a catch clause), - * function-block, or source file. - */ function getThrowStatementOwner(throwStatement) { var child = throwStatement; while (child.parent) { var parent_9 = child.parent; - if (ts.isFunctionBlock(parent_9) || parent_9.kind === 228 /* SourceFile */) { + if (ts.isFunctionBlock(parent_9) || parent_9.kind === 228) { return parent_9; } - // A throw-statement is only owned by a try-statement if the try-statement has - // a catch clause, and if the throw-statement occurs within the try block. - if (parent_9.kind === 197 /* TryStatement */) { + if (parent_9.kind === 197) { var tryStatement = parent_9; if (tryStatement.tryBlock === child && tryStatement.catchClause) { return child; @@ -39216,7 +33277,7 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 191 /* BreakStatement */ || node.kind === 190 /* ContinueStatement */) { + if (node.kind === 191 || node.kind === 190) { statementAccumulator.push(node); } else if (!ts.isFunctionLike(node)) { @@ -39232,22 +33293,20 @@ var ts; function getBreakOrContinueOwner(statement) { for (var node_1 = statement.parent; node_1; node_1 = node_1.parent) { switch (node_1.kind) { - case 194 /* SwitchStatement */: - if (statement.kind === 190 /* ContinueStatement */) { + case 194: + if (statement.kind === 190) { continue; } - // Fall through. - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: + case 187: + case 188: + case 189: + case 186: + case 185: if (!statement.label || isLabeledBy(node_1, statement.label.text)) { return node_1; } break; default: - // Don't cross function boundaries. if (ts.isFunctionLike(node_1)) { return undefined; } @@ -39258,45 +33317,41 @@ var ts; } function getModifierOccurrences(modifier, declaration) { var container = declaration.parent; - // Make sure we only highlight the keyword when it makes sense to do so. if (ts.isAccessibilityModifier(modifier)) { - if (!(container.kind === 202 /* ClassDeclaration */ || - (declaration.kind === 130 /* Parameter */ && hasKind(container, 136 /* Constructor */)))) { + if (!(container.kind === 202 || + (declaration.kind === 130 && hasKind(container, 136)))) { return undefined; } } - else if (modifier === 109 /* StaticKeyword */) { - if (container.kind !== 202 /* ClassDeclaration */) { + else if (modifier === 109) { + if (container.kind !== 202) { return undefined; } } - else if (modifier === 78 /* ExportKeyword */ || modifier === 115 /* DeclareKeyword */) { - if (!(container.kind === 207 /* ModuleBlock */ || container.kind === 228 /* SourceFile */)) { + else if (modifier === 78 || modifier === 115) { + if (!(container.kind === 207 || container.kind === 228)) { return undefined; } } else { - // unsupported modifier return undefined; } var keywords = []; var modifierFlag = getFlagFromModifier(modifier); var nodes; switch (container.kind) { - case 207 /* ModuleBlock */: - case 228 /* SourceFile */: + case 207: + case 228: nodes = container.statements; break; - case 136 /* Constructor */: + case 136: nodes = container.parameters.concat(container.parent.members); break; - case 202 /* ClassDeclaration */: + case 202: nodes = container.members; - // If we're an accessibility modifier, we're in an instance member and should search - // the constructor's parameter list for instance members as well. - if (modifierFlag & 112 /* AccessibilityModifier */) { + if (modifierFlag & 112) { var constructor = ts.forEach(container.members, function (member) { - return member.kind === 136 /* Constructor */ && member; + return member.kind === 136 && member; }); if (constructor) { nodes = nodes.concat(constructor.parameters); @@ -39314,18 +33369,18 @@ var ts; return ts.map(keywords, getHighlightSpanForNode); function getFlagFromModifier(modifier) { switch (modifier) { - case 108 /* PublicKeyword */: - return 16 /* Public */; - case 106 /* PrivateKeyword */: - return 32 /* Private */; - case 107 /* ProtectedKeyword */: - return 64 /* Protected */; - case 109 /* StaticKeyword */: - return 128 /* Static */; - case 78 /* ExportKeyword */: - return 1 /* Export */; - case 115 /* DeclareKeyword */: - return 2 /* Ambient */; + case 108: + return 16; + case 106: + return 32; + case 107: + return 64; + case 109: + return 128; + case 78: + return 1; + case 115: + return 2; default: ts.Debug.fail(); } @@ -39344,13 +33399,13 @@ var ts; } function getGetAndSetOccurrences(accessorDeclaration) { var keywords = []; - tryPushAccessorKeyword(accessorDeclaration.symbol, 137 /* GetAccessor */); - tryPushAccessorKeyword(accessorDeclaration.symbol, 138 /* SetAccessor */); + tryPushAccessorKeyword(accessorDeclaration.symbol, 137); + tryPushAccessorKeyword(accessorDeclaration.symbol, 138); return ts.map(keywords, getHighlightSpanForNode); function tryPushAccessorKeyword(accessorSymbol, accessorKind) { var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind); if (accessor) { - ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116 /* GetKeyword */, 121 /* SetKeyword */); }); + ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116, 121); }); } } } @@ -39359,19 +33414,18 @@ var ts; var keywords = []; ts.forEach(declarations, function (declaration) { ts.forEach(declaration.getChildren(), function (token) { - return pushKeywordIf(keywords, token, 114 /* ConstructorKeyword */); + return pushKeywordIf(keywords, token, 114); }); }); return ts.map(keywords, getHighlightSpanForNode); } function getLoopBreakContinueOccurrences(loopNode) { var keywords = []; - if (pushKeywordIf(keywords, loopNode.getFirstToken(), 82 /* ForKeyword */, 100 /* WhileKeyword */, 75 /* DoKeyword */)) { - // If we succeeded and got a do-while loop, then start looking for a 'while' keyword. - if (loopNode.kind === 185 /* DoStatement */) { + if (pushKeywordIf(keywords, loopNode.getFirstToken(), 82, 100, 75)) { + if (loopNode.kind === 185) { var loopTokens = loopNode.getChildren(); for (var i = loopTokens.length - 1; i >= 0; i--) { - if (pushKeywordIf(keywords, loopTokens[i], 100 /* WhileKeyword */)) { + if (pushKeywordIf(keywords, loopTokens[i], 100)) { break; } } @@ -39380,7 +33434,7 @@ var ts; var breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement); ts.forEach(breaksAndContinues, function (statement) { if (ownsBreakOrContinueStatement(loopNode, statement)) { - pushKeywordIf(keywords, statement.getFirstToken(), 66 /* BreakKeyword */, 71 /* ContinueKeyword */); + pushKeywordIf(keywords, statement.getFirstToken(), 66, 71); } }); return ts.map(keywords, getHighlightSpanForNode); @@ -39389,13 +33443,13 @@ var ts; var owner = getBreakOrContinueOwner(breakOrContinueStatement); if (owner) { switch (owner.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: + case 187: + case 188: + case 189: + case 185: + case 186: return getLoopBreakContinueOccurrences(owner); - case 194 /* SwitchStatement */: + case 194: return getSwitchCaseDefaultOccurrences(owner); } } @@ -39403,14 +33457,13 @@ var ts; } function getSwitchCaseDefaultOccurrences(switchStatement) { var keywords = []; - pushKeywordIf(keywords, switchStatement.getFirstToken(), 92 /* SwitchKeyword */); - // Go through each clause in the switch statement, collecting the 'case'/'default' keywords. + pushKeywordIf(keywords, switchStatement.getFirstToken(), 92); ts.forEach(switchStatement.caseBlock.clauses, function (clause) { - pushKeywordIf(keywords, clause.getFirstToken(), 67 /* CaseKeyword */, 73 /* DefaultKeyword */); + pushKeywordIf(keywords, clause.getFirstToken(), 67, 73); var breaksAndContinues = aggregateAllBreakAndContinueStatements(clause); ts.forEach(breaksAndContinues, function (statement) { if (ownsBreakOrContinueStatement(switchStatement, statement)) { - pushKeywordIf(keywords, statement.getFirstToken(), 66 /* BreakKeyword */); + pushKeywordIf(keywords, statement.getFirstToken(), 66); } }); }); @@ -39418,13 +33471,13 @@ var ts; } function getTryCatchFinallyOccurrences(tryStatement) { var keywords = []; - pushKeywordIf(keywords, tryStatement.getFirstToken(), 96 /* TryKeyword */); + pushKeywordIf(keywords, tryStatement.getFirstToken(), 96); if (tryStatement.catchClause) { - pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), 68 /* CatchKeyword */); + pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), 68); } if (tryStatement.finallyBlock) { - var finallyKeyword = ts.findChildOfKind(tryStatement, 81 /* FinallyKeyword */, sourceFile); - pushKeywordIf(keywords, finallyKeyword, 81 /* FinallyKeyword */); + var finallyKeyword = ts.findChildOfKind(tryStatement, 81, sourceFile); + pushKeywordIf(keywords, finallyKeyword, 81); } return ts.map(keywords, getHighlightSpanForNode); } @@ -39435,63 +33488,53 @@ var ts; } var keywords = []; ts.forEach(aggregateOwnedThrowStatements(owner), function (throwStatement) { - pushKeywordIf(keywords, throwStatement.getFirstToken(), 94 /* ThrowKeyword */); + pushKeywordIf(keywords, throwStatement.getFirstToken(), 94); }); - // If the "owner" is a function, then we equate 'return' and 'throw' statements in their - // ability to "jump out" of the function, and include occurrences for both. if (ts.isFunctionBlock(owner)) { ts.forEachReturnStatement(owner, function (returnStatement) { - pushKeywordIf(keywords, returnStatement.getFirstToken(), 90 /* ReturnKeyword */); + pushKeywordIf(keywords, returnStatement.getFirstToken(), 90); }); } return ts.map(keywords, getHighlightSpanForNode); } function getReturnOccurrences(returnStatement) { var func = ts.getContainingFunction(returnStatement); - // If we didn't find a containing function with a block body, bail out. - if (!(func && hasKind(func.body, 180 /* Block */))) { + if (!(func && hasKind(func.body, 180))) { return undefined; } var keywords = []; ts.forEachReturnStatement(func.body, function (returnStatement) { - pushKeywordIf(keywords, returnStatement.getFirstToken(), 90 /* ReturnKeyword */); + pushKeywordIf(keywords, returnStatement.getFirstToken(), 90); }); - // Include 'throw' statements that do not occur within a try block. ts.forEach(aggregateOwnedThrowStatements(func.body), function (throwStatement) { - pushKeywordIf(keywords, throwStatement.getFirstToken(), 94 /* ThrowKeyword */); + pushKeywordIf(keywords, throwStatement.getFirstToken(), 94); }); return ts.map(keywords, getHighlightSpanForNode); } function getIfElseOccurrences(ifStatement) { var keywords = []; - // Traverse upwards through all parent if-statements linked by their else-branches. - while (hasKind(ifStatement.parent, 184 /* IfStatement */) && ifStatement.parent.elseStatement === ifStatement) { + while (hasKind(ifStatement.parent, 184) && ifStatement.parent.elseStatement === ifStatement) { ifStatement = ifStatement.parent; } - // Now traverse back down through the else branches, aggregating if/else keywords of if-statements. while (ifStatement) { var children = ifStatement.getChildren(); - pushKeywordIf(keywords, children[0], 84 /* IfKeyword */); - // Generally the 'else' keyword is second-to-last, so we traverse backwards. + pushKeywordIf(keywords, children[0], 84); for (var i = children.length - 1; i >= 0; i--) { - if (pushKeywordIf(keywords, children[i], 76 /* ElseKeyword */)) { + if (pushKeywordIf(keywords, children[i], 76)) { break; } } - if (!hasKind(ifStatement.elseStatement, 184 /* IfStatement */)) { + if (!hasKind(ifStatement.elseStatement, 184)) { break; } ifStatement = ifStatement.elseStatement; } var result = []; - // We'd like to highlight else/ifs together if they are only separated by whitespace - // (i.e. the keywords are separated by no comments, no newlines). for (var i = 0; i < keywords.length; i++) { - if (keywords[i].kind === 76 /* ElseKeyword */ && i < keywords.length - 1) { + if (keywords[i].kind === 76 && i < keywords.length - 1) { var elseKeyword = keywords[i]; - var ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword. + var ifKeyword = keywords[i + 1]; var shouldCombindElseAndIf = true; - // Avoid recalculating getStart() by iterating backwards. for (var j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) { if (!ts.isWhiteSpace(sourceFile.text.charCodeAt(j))) { shouldCombindElseAndIf = false; @@ -39504,18 +33547,16 @@ var ts; textSpan: ts.createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end), kind: HighlightSpanKind.reference }); - i++; // skip the next keyword + i++; continue; } } - // Ordinary case: just highlight the keyword. result.push(getHighlightSpanForNode(keywords[i])); } return result; } } } - /// References and Occurrences function getOccurrencesAtPositionCore(fileName, position) { synchronizeHostData(); return convertDocumentHighlights(getDocumentHighlights(fileName, position, [fileName])); @@ -39559,7 +33600,6 @@ var ts; } function findReferences(fileName, position) { var referencedSymbols = findReferencedSymbols(fileName, position, false, false); - // Only include referenced symbols that have a valid definition. return ts.filter(referencedSymbols, function (rs) { return !!rs.definition; }); } function findReferencedSymbols(fileName, position, findInStrings, findInComments) { @@ -39569,58 +33609,43 @@ var ts; if (!node) { return undefined; } - if (node.kind !== 65 /* Identifier */ && - // TODO (drosen): This should be enabled in a later release - currently breaks rename. - //node.kind !== SyntaxKind.ThisKeyword && - //node.kind !== SyntaxKind.SuperKeyword && + if (node.kind !== 65 && !isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && !isNameOfExternalModuleImportOrDeclaration(node)) { return undefined; } - ts.Debug.assert(node.kind === 65 /* Identifier */ || node.kind === 7 /* NumericLiteral */ || node.kind === 8 /* StringLiteral */); + ts.Debug.assert(node.kind === 65 || node.kind === 7 || node.kind === 8); return getReferencedSymbolsForNodes(node, program.getSourceFiles(), findInStrings, findInComments); } function getReferencedSymbolsForNodes(node, sourceFiles, findInStrings, findInComments) { var typeChecker = program.getTypeChecker(); - // Labels if (isLabelName(node)) { if (isJumpStatementTarget(node)) { var labelDefinition = getTargetLabel(node.parent, node.text); - // if we have a label definition, look within its statement for references, if not, then - // the label is undefined and we have no results.. return labelDefinition ? getLabelReferencesInNode(labelDefinition.parent, labelDefinition) : undefined; } else { - // it is a label definition and not a target, search within the parent labeledStatement return getLabelReferencesInNode(node.parent, node); } } - if (node.kind === 93 /* ThisKeyword */) { + if (node.kind === 93) { return getReferencesForThisKeyword(node, sourceFiles); } - if (node.kind === 91 /* SuperKeyword */) { + if (node.kind === 91) { return getReferencesForSuperKeyword(node); } var symbol = typeChecker.getSymbolAtLocation(node); - // Could not find a symbol e.g. unknown identifier if (!symbol) { - // Can't have references to something that we have no symbol for. return undefined; } var declarations = symbol.declarations; - // The symbol was an internal symbol and does not have a declaration e.g.undefined symbol if (!declarations || !declarations.length) { return undefined; } var result; - // Compute the meaning from the location and the symbol it references var searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations); - // Get the text to search for, we need to normalize it as external module names will have quote var declaredName = getDeclaredName(symbol, node); - // Try to get the smallest valid scope that we can limit our search to; - // otherwise we'll need to search globally (i.e. include each file). var scope = getSymbolScope(symbol); - // Maps from a symbol ID to the ReferencedSymbol entry in 'result'. var symbolToIndex = []; if (scope) { result = []; @@ -39657,29 +33682,20 @@ var ts; } function isImportOrExportSpecifierName(location) { return location.parent && - (location.parent.kind === 214 /* ImportSpecifier */ || location.parent.kind === 218 /* ExportSpecifier */) && + (location.parent.kind === 214 || location.parent.kind === 218) && location.parent.propertyName === location; } function isImportOrExportSpecifierImportSymbol(symbol) { - return (symbol.flags & 8388608 /* Alias */) && ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 214 /* ImportSpecifier */ || declaration.kind === 218 /* ExportSpecifier */; + return (symbol.flags & 8388608) && ts.forEach(symbol.declarations, function (declaration) { + return declaration.kind === 214 || declaration.kind === 218; }); } function getDeclaredName(symbol, location) { - // Special case for function expressions, whose names are solely local to their bodies. - var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 163 /* FunctionExpression */ ? d : undefined; }); - // When a name gets interned into a SourceFile's 'identifiers' Map, - // its name is escaped and stored in the same way its symbol name/identifier - // name should be stored. Function expressions, however, are a special case, - // because despite sometimes having a name, the binder unconditionally binds them - // to a symbol with the name "__function". + var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 163 ? d : undefined; }); var name; if (functionExpression && functionExpression.name) { name = functionExpression.name.text; } - // If this is an export or import specifier it could have been renamed using the as syntax. - // if so we want to search for whatever under the cursor, the symbol is pointing to the alias (name) - // so check for the propertyName. if (isImportOrExportSpecifierName(location)) { return location.getText(); } @@ -39687,19 +33703,10 @@ var ts; return stripQuotes(name); } function getInternedName(symbol, location, declarations) { - // If this is an export or import specifier it could have been renamed using the as syntax. - // if so we want to search for whatever under the cursor, the symbol is pointing to the alias (name) - // so check for the propertyName. if (isImportOrExportSpecifierName(location)) { return location.getText(); } - // Special case for function expressions, whose names are solely local to their bodies. - var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 163 /* FunctionExpression */ ? d : undefined; }); - // When a name gets interned into a SourceFile's 'identifiers' Map, - // its name is escaped and stored in the same way its symbol name/identifier - // name should be stored. Function expressions, however, are a special case, - // because despite sometimes having a name, the binder unconditionally binds them - // to a symbol with the name "__function". + var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 163 ? d : undefined; }); var name = functionExpression && functionExpression.name ? functionExpression.name.text : symbol.name; @@ -39707,28 +33714,23 @@ var ts; } function stripQuotes(name) { var length = name.length; - if (length >= 2 && name.charCodeAt(0) === 34 /* doubleQuote */ && name.charCodeAt(length - 1) === 34 /* doubleQuote */) { + if (length >= 2 && name.charCodeAt(0) === 34 && name.charCodeAt(length - 1) === 34) { return name.substring(1, length - 1); } ; return name; } function getSymbolScope(symbol) { - // If this is private property or method, the scope is the containing class - if (symbol.flags & (4 /* Property */ | 8192 /* Method */)) { - var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32 /* Private */) ? d : undefined; }); + if (symbol.flags & (4 | 8192)) { + var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32) ? d : undefined; }); if (privateDeclaration) { - return ts.getAncestor(privateDeclaration, 202 /* ClassDeclaration */); + return ts.getAncestor(privateDeclaration, 202); } } - // If the symbol is an import we would like to find it if we are looking for what it imports. - // So consider it visibile outside its declaration scope. - if (symbol.flags & 8388608 /* Alias */) { + if (symbol.flags & 8388608) { return undefined; } - // if this symbol is visible from its parent container, e.g. exported, then bail out - // if symbol correspond to the union property - bail out - if (symbol.parent || (symbol.flags & 268435456 /* UnionProperty */)) { + if (symbol.parent || (symbol.flags & 268435456)) { return undefined; } var scope = undefined; @@ -39741,15 +33743,11 @@ var ts; return undefined; } if (scope && scope !== container) { - // Different declarations have different containers, bail out return undefined; } - if (container.kind === 228 /* SourceFile */ && !ts.isExternalModule(container)) { - // This is a global variable and not an external module, any declaration defined - // within this scope is visible outside the file + if (container.kind === 228 && !ts.isExternalModule(container)) { return undefined; } - // The search scope is the container node scope = container; } } @@ -39757,9 +33755,6 @@ var ts; } function getPossibleSymbolReferencePositions(sourceFile, symbolName, start, end) { var positions = []; - /// TODO: Cache symbol existence for files to save text search - // Also, need to make this work for unicode escapes. - // Be resilient in the face of a symbol with no name or zero length name if (!symbolName || !symbolName.length) { return positions; } @@ -39769,15 +33764,11 @@ var ts; var position = text.indexOf(symbolName, start); while (position >= 0) { cancellationToken.throwIfCancellationRequested(); - // If we are past the end, stop looking if (position > end) break; - // We found a match. Make sure it's not part of a larger word (i.e. the char - // before and after it have to be a non-identifier char). var endPosition = position + symbolNameLength; - if ((position === 0 || !ts.isIdentifierPart(text.charCodeAt(position - 1), 2 /* Latest */)) && - (endPosition === sourceLength || !ts.isIdentifierPart(text.charCodeAt(endPosition), 2 /* Latest */))) { - // Found a real match. Keep searching. + if ((position === 0 || !ts.isIdentifierPart(text.charCodeAt(position - 1), 2)) && + (endPosition === sourceLength || !ts.isIdentifierPart(text.charCodeAt(endPosition), 2))) { positions.push(position); } position = text.indexOf(symbolName, position + symbolNameLength + 1); @@ -39795,7 +33786,6 @@ var ts; if (!node || node.getWidth() !== labelName.length) { return; } - // Only pick labels that are either the target label, or have a target that is the target label if (node === targetLabel || (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel)) { references.push(getReferenceEntryFromNode(node)); @@ -39813,18 +33803,16 @@ var ts; } function isValidReferencePosition(node, searchSymbolName) { if (node) { - // Compare the length so we filter out strict superstrings of the symbol we are looking for switch (node.kind) { - case 65 /* Identifier */: + case 65: return node.getWidth() === searchSymbolName.length; - case 8 /* StringLiteral */: + case 8: if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) { - // For string literals we have two additional chars for the quotes return node.getWidth() === searchSymbolName.length + 2; } break; - case 7 /* NumericLiteral */: + case 7: if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) { return node.getWidth() === searchSymbolName.length; } @@ -39833,30 +33821,18 @@ var ts; } return false; } - /** Search within node "container" for references for a search value, where the search value is defined as a - * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning). - * searchLocation: a node where the search value - */ function getReferencesInNode(container, searchSymbol, searchText, searchLocation, searchMeaning, findInStrings, findInComments, result, symbolToIndex) { var sourceFile = container.getSourceFile(); var tripleSlashDirectivePrefixRegex = /^\/\/\/\s*= 0) { + else if (!(referenceSymbol.flags & 67108864) && searchSymbols.indexOf(shorthandValueSymbol) >= 0) { var referencedSymbol = getReferencedSymbol(shorthandValueSymbol); referencedSymbol.references.push(getReferenceEntryFromNode(referenceSymbolDeclaration.name)); } @@ -39903,15 +33879,12 @@ var ts; } function isInString(position) { var token = ts.getTokenAtPosition(sourceFile, position); - return token && token.kind === 8 /* StringLiteral */ && position > token.getStart(); + return token && token.kind === 8 && position > token.getStart(); } function isInComment(position) { var token = ts.getTokenAtPosition(sourceFile, position); if (token && position < token.getStart()) { - // First, we have to see if this position actually landed in a comment. var commentRanges = ts.getLeadingCommentRanges(sourceFile.text, token.pos); - // Then we want to make sure that it wasn't in a "///<" directive comment - // We don't want to unintentionally update a file name. return ts.forEach(commentRanges, function (c) { if (c.pos < position && position < c.end) { var commentText = sourceFile.text.substring(c.pos, c.end); @@ -39929,18 +33902,17 @@ var ts; if (!searchSpaceNode) { return undefined; } - // Whether 'super' occurs in a static context within a class. - var staticFlag = 128 /* Static */; + var staticFlag = 128; switch (searchSpaceNode.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 133: + case 132: + case 135: + case 134: + case 136: + case 137: + case 138: staticFlag &= searchSpaceNode.flags; - searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class + searchSpaceNode = searchSpaceNode.parent; break; default: return undefined; @@ -39951,14 +33923,11 @@ var ts; ts.forEach(possiblePositions, function (position) { cancellationToken.throwIfCancellationRequested(); var node = ts.getTouchingWord(sourceFile, position); - if (!node || node.kind !== 91 /* SuperKeyword */) { + if (!node || node.kind !== 91) { return; } var container = ts.getSuperContainer(node, false); - // If we have a 'super' container, we must have an enclosing class. - // Now make sure the owning class is the same as the search-space - // and has the same static qualifier as the original 'super's owner. - if (container && (128 /* Static */ & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) { + if (container && (128 & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) { references.push(getReferenceEntryFromNode(node)); } }); @@ -39967,39 +33936,34 @@ var ts; } function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles) { var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, false); - // Whether 'this' occurs in a static context within a class. - var staticFlag = 128 /* Static */; + var staticFlag = 128; switch (searchSpaceNode.kind) { - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: if (ts.isObjectLiteralMethod(searchSpaceNode)) { break; } - // fall through - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 133: + case 132: + case 136: + case 137: + case 138: staticFlag &= searchSpaceNode.flags; - searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class + searchSpaceNode = searchSpaceNode.parent; break; - case 228 /* SourceFile */: + case 228: if (ts.isExternalModule(searchSpaceNode)) { return undefined; } - // Fall through - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: + case 201: + case 163: break; - // Computed properties in classes are not handled here because references to this are illegal, - // so there is no point finding references to them. default: return undefined; } var references = []; var possiblePositions; - if (searchSpaceNode.kind === 228 /* SourceFile */) { + if (searchSpaceNode.kind === 228) { ts.forEach(sourceFiles, function (sourceFile) { possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references); @@ -40025,32 +33989,30 @@ var ts; ts.forEach(possiblePositions, function (position) { cancellationToken.throwIfCancellationRequested(); var node = ts.getTouchingWord(sourceFile, position); - if (!node || node.kind !== 93 /* ThisKeyword */) { + if (!node || node.kind !== 93) { return; } var container = ts.getThisContainer(node, false); switch (searchSpaceNode.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: + case 163: + case 201: if (searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 135: + case 134: if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 202 /* ClassDeclaration */: - // Make sure the container belongs to the same class - // and has the appropriate static modifier from the original container. - if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128 /* Static */) === staticFlag) { + case 202: + if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128) === staticFlag) { result.push(getReferenceEntryFromNode(node)); } break; - case 228 /* SourceFile */: - if (container.kind === 228 /* SourceFile */ && !ts.isExternalModule(container)) { + case 228: + if (container.kind === 228 && !ts.isExternalModule(container)) { result.push(getReferenceEntryFromNode(node)); } break; @@ -40059,56 +34021,37 @@ var ts; } } function populateSearchSymbolSet(symbol, location) { - // The search set contains at least the current symbol var result = [symbol]; - // If the symbol is an alias, add what it alaises to the list if (isImportOrExportSpecifierImportSymbol(symbol)) { result.push(typeChecker.getAliasedSymbol(symbol)); } - // If the location is in a context sensitive location (i.e. in an object literal) try - // to get a contextual type for it, and add the property symbol from the contextual - // type to the search set if (isNameOfPropertyAssignment(location)) { ts.forEach(getPropertySymbolsFromContextualType(location), function (contextualSymbol) { result.push.apply(result, typeChecker.getRootSymbols(contextualSymbol)); }); - /* Because in short-hand property assignment, location has two meaning : property name and as value of the property - * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of - * property name and variable declaration of the identifier. - * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service - * should show both 'name' in 'obj' and 'name' in variable declaration - * let name = "Foo"; - * let obj = { name }; - * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment - * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration - * will be included correctly. - */ var shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(location.parent); if (shorthandValueSymbol) { result.push(shorthandValueSymbol); } } - // If this is a union property, add all the symbols from all its source symbols in all unioned types. - // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list ts.forEach(typeChecker.getRootSymbols(symbol), function (rootSymbol) { if (rootSymbol !== symbol) { result.push(rootSymbol); } - // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions - if (rootSymbol.parent && rootSymbol.parent.flags & (32 /* Class */ | 64 /* Interface */)) { + if (rootSymbol.parent && rootSymbol.parent.flags & (32 | 64)) { getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result); } }); return result; } function getPropertySymbolsFromBaseTypes(symbol, propertyName, result) { - if (symbol && symbol.flags & (32 /* Class */ | 64 /* Interface */)) { + if (symbol && symbol.flags & (32 | 64)) { ts.forEach(symbol.getDeclarations(), function (declaration) { - if (declaration.kind === 202 /* ClassDeclaration */) { + if (declaration.kind === 202) { getPropertySymbolFromTypeReference(ts.getClassExtendsHeritageClauseElement(declaration)); ts.forEach(ts.getClassImplementsHeritageClauseElements(declaration), getPropertySymbolFromTypeReference); } - else if (declaration.kind === 203 /* InterfaceDeclaration */) { + else if (declaration.kind === 203) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference); } }); @@ -40122,7 +34065,6 @@ var ts; if (propertySymbol) { result.push(propertySymbol); } - // Visit the typeReference as well to see if it directly or indirectly use that property getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result); } } @@ -40132,32 +34074,22 @@ var ts; if (searchSymbols.indexOf(referenceSymbol) >= 0) { return referenceSymbol; } - // If the reference symbol is an alias, check if what it is aliasing is one of the search - // symbols. if (isImportOrExportSpecifierImportSymbol(referenceSymbol)) { var aliasedSymbol = typeChecker.getAliasedSymbol(referenceSymbol); if (searchSymbols.indexOf(aliasedSymbol) >= 0) { return aliasedSymbol; } } - // If the reference location is in an object literal, try to get the contextual type for the - // object literal, lookup the property symbol in the contextual type, and use this symbol to - // compare to our searchSymbol if (isNameOfPropertyAssignment(referenceLocation)) { return ts.forEach(getPropertySymbolsFromContextualType(referenceLocation), function (contextualSymbol) { return ts.forEach(typeChecker.getRootSymbols(contextualSymbol), function (s) { return searchSymbols.indexOf(s) >= 0 ? s : undefined; }); }); } - // Unwrap symbols to get to the root (e.g. transient symbols as a result of widening) - // Or a union property, use its underlying unioned symbols return ts.forEach(typeChecker.getRootSymbols(referenceSymbol), function (rootSymbol) { - // if it is in the list, then we are done if (searchSymbols.indexOf(rootSymbol) >= 0) { return rootSymbol; } - // Finally, try all properties with the same name in any type the containing type extended or implemented, and - // see if any is in the list - if (rootSymbol.parent && rootSymbol.parent.flags & (32 /* Class */ | 64 /* Interface */)) { + if (rootSymbol.parent && rootSymbol.parent.flags & (32 | 64)) { var result_3 = []; getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result_3); return ts.forEach(result_3, function (s) { return searchSymbols.indexOf(s) >= 0 ? s : undefined; }); @@ -40171,9 +34103,7 @@ var ts; var contextualType = typeChecker.getContextualType(objectLiteral); var name_26 = node.text; if (contextualType) { - if (contextualType.flags & 16384 /* Union */) { - // This is a union type, first see if the property we are looking for is a union property (i.e. exists in all types) - // if not, search the constituent types for the property + if (contextualType.flags & 16384) { var unionProperty = contextualType.getProperty(name_26); if (unionProperty) { return [unionProperty]; @@ -40199,22 +34129,10 @@ var ts; } return undefined; } - /** Given an initial searchMeaning, extracted from a location, widen the search scope based on the declarations - * of the corresponding symbol. e.g. if we are searching for "Foo" in value position, but "Foo" references a class - * then we need to widen the search to include type positions as well. - * On the contrary, if we are searching for "Bar" in type position and we trace bar to an interface, and an uninstantiated - * module, we want to keep the search limited to only types, as the two declarations (interface and uninstantiated module) - * do not intersect in any of the three spaces. - */ function getIntersectingMeaningFromDeclarations(meaning, declarations) { if (declarations) { var lastIterationMeaning; do { - // The result is order-sensitive, for instance if initialMeaning === Namespace, and declarations = [class, instantiated module] - // we need to consider both as they initialMeaning intersects with the module in the namespace space, and the module - // intersects with the class in the value space. - // To achieve that we will keep iterating until the result stabilizes. - // Remember the last meaning lastIterationMeaning = meaning; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; @@ -40231,7 +34149,7 @@ var ts; function getReferenceEntryFromNode(node) { var start = node.getStart(); var end = node.getEnd(); - if (node.kind === 8 /* StringLiteral */) { + if (node.kind === 8) { start += 1; end -= 1; } @@ -40241,24 +34159,22 @@ var ts; isWriteAccess: isWriteAccess(node) }; } - /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */ function isWriteAccess(node) { - if (node.kind === 65 /* Identifier */ && ts.isDeclarationName(node)) { + if (node.kind === 65 && ts.isDeclarationName(node)) { return true; } var parent = node.parent; if (parent) { - if (parent.kind === 169 /* PostfixUnaryExpression */ || parent.kind === 168 /* PrefixUnaryExpression */) { + if (parent.kind === 169 || parent.kind === 168) { return true; } - else if (parent.kind === 170 /* BinaryExpression */ && parent.left === node) { + else if (parent.kind === 170 && parent.left === node) { var operator = parent.operatorToken.kind; - return 53 /* FirstAssignment */ <= operator && operator <= 64 /* LastAssignment */; + return 53 <= operator && operator <= 64; } } return false; } - /// NavigateTo function getNavigateToItems(searchValue, maxResultCount) { synchronizeHostData(); return ts.NavigateTo.getNavigateToItems(program, cancellationToken, searchValue, maxResultCount); @@ -40285,61 +34201,60 @@ var ts; } function getMeaningFromDeclaration(node) { switch (node.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 224 /* CatchClause */: - return 1 /* Value */; - case 129 /* TypeParameter */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 146 /* TypeLiteral */: - return 2 /* Type */; - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - return 1 /* Value */ | 2 /* Type */; - case 206 /* ModuleDeclaration */: - if (node.name.kind === 8 /* StringLiteral */) { - return 4 /* Namespace */ | 1 /* Value */; - } - else if (ts.getModuleInstanceState(node) === 1 /* Instantiated */) { - return 4 /* Namespace */ | 1 /* Value */; + case 130: + case 199: + case 153: + case 133: + case 132: + case 225: + case 226: + case 227: + case 135: + case 134: + case 136: + case 137: + case 138: + case 201: + case 163: + case 164: + case 224: + return 1; + case 129: + case 203: + case 204: + case 146: + return 2; + case 202: + case 205: + return 1 | 2; + case 206: + if (node.name.kind === 8) { + return 4 | 1; + } + else if (ts.getModuleInstanceState(node) === 1) { + return 4 | 1; } else { - return 4 /* Namespace */; - } - case 213 /* NamedImports */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 210 /* ImportDeclaration */: - case 215 /* ExportAssignment */: - case 216 /* ExportDeclaration */: - return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; - // An external module can be a Value - case 228 /* SourceFile */: - return 4 /* Namespace */ | 1 /* Value */; - } - return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; + return 4; + } + case 213: + case 214: + case 209: + case 210: + case 215: + case 216: + return 1 | 2 | 4; + case 228: + return 4 | 1; + } + return 1 | 2 | 4; ts.Debug.fail("Unknown declaration type"); } function isTypeReference(node) { if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) { node = node.parent; } - return node.parent.kind === 142 /* TypeReference */ || node.parent.kind === 177 /* ExpressionWithTypeArguments */; + return node.parent.kind === 142 || node.parent.kind === 177; } function isNamespaceReference(node) { return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node); @@ -40347,51 +34262,48 @@ var ts; function isPropertyAccessNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 156 /* PropertyAccessExpression */) { - while (root.parent && root.parent.kind === 156 /* PropertyAccessExpression */) { + if (root.parent.kind === 156) { + while (root.parent && root.parent.kind === 156) { root = root.parent; } isLastClause = root.name === node; } - if (!isLastClause && root.parent.kind === 177 /* ExpressionWithTypeArguments */ && root.parent.parent.kind === 223 /* HeritageClause */) { + if (!isLastClause && root.parent.kind === 177 && root.parent.parent.kind === 223) { var decl = root.parent.parent.parent; - return (decl.kind === 202 /* ClassDeclaration */ && root.parent.parent.token === 102 /* ImplementsKeyword */) || - (decl.kind === 203 /* InterfaceDeclaration */ && root.parent.parent.token === 79 /* ExtendsKeyword */); + return (decl.kind === 202 && root.parent.parent.token === 102) || + (decl.kind === 203 && root.parent.parent.token === 79); } return false; } function isQualifiedNameNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 127 /* QualifiedName */) { - while (root.parent && root.parent.kind === 127 /* QualifiedName */) { + if (root.parent.kind === 127) { + while (root.parent && root.parent.kind === 127) { root = root.parent; } isLastClause = root.right === node; } - return root.parent.kind === 142 /* TypeReference */ && !isLastClause; + return root.parent.kind === 142 && !isLastClause; } function isInRightSideOfImport(node) { - while (node.parent.kind === 127 /* QualifiedName */) { + while (node.parent.kind === 127) { node = node.parent; } return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; } function getMeaningFromRightHandSideOfImportEquals(node) { - ts.Debug.assert(node.kind === 65 /* Identifier */); - // import a = |b|; // Namespace - // import a = |b.c|; // Value, type, namespace - // import a = |b.c|.d; // Namespace - if (node.parent.kind === 127 /* QualifiedName */ && + ts.Debug.assert(node.kind === 65); + if (node.parent.kind === 127 && node.parent.right === node && - node.parent.parent.kind === 209 /* ImportEqualsDeclaration */) { - return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; + node.parent.parent.kind === 209) { + return 1 | 2 | 4; } - return 4 /* Namespace */; + return 4; } function getMeaningFromLocation(node) { - if (node.parent.kind === 215 /* ExportAssignment */) { - return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; + if (node.parent.kind === 215) { + return 1 | 2 | 4; } else if (isInRightSideOfImport(node)) { return getMeaningFromRightHandSideOfImportEquals(node); @@ -40400,79 +34312,64 @@ var ts; return getMeaningFromDeclaration(node.parent); } else if (isTypeReference(node)) { - return 2 /* Type */; + return 2; } else if (isNamespaceReference(node)) { - return 4 /* Namespace */; + return 4; } else { - return 1 /* Value */; + return 1; } } - // Signature help - /** - * This is a semantic operation. - */ function getSignatureHelpItems(fileName, position) { synchronizeHostData(); var sourceFile = getValidSourceFile(fileName); return ts.SignatureHelp.getSignatureHelpItems(program, sourceFile, position, cancellationToken); } - /// Syntactic features function getSourceFile(fileName) { return syntaxTreeCache.getCurrentSourceFile(fileName); } function getNameOrDottedNameSpan(fileName, startPos, endPos) { var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - // Get node at the location var node = ts.getTouchingPropertyName(sourceFile, startPos); if (!node) { return; } switch (node.kind) { - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: - case 8 /* StringLiteral */: - case 80 /* FalseKeyword */: - case 95 /* TrueKeyword */: - case 89 /* NullKeyword */: - case 91 /* SuperKeyword */: - case 93 /* ThisKeyword */: - case 65 /* Identifier */: + case 156: + case 127: + case 8: + case 80: + case 95: + case 89: + case 91: + case 93: + case 65: break; - // Cant create the text span default: return; } var nodeForStartPos = node; while (true) { if (isRightSideOfPropertyAccess(nodeForStartPos) || isRightSideOfQualifiedName(nodeForStartPos)) { - // If on the span is in right side of the the property or qualified name, return the span from the qualified name pos to end of this node nodeForStartPos = nodeForStartPos.parent; } else if (isNameOfModuleDeclaration(nodeForStartPos)) { - // If this is name of a module declarations, check if this is right side of dotted module name - // If parent of the module declaration which is parent of this node is module declaration and its body is the module declaration that this node is name of - // Then this name is name from dotted module - if (nodeForStartPos.parent.parent.kind === 206 /* ModuleDeclaration */ && + if (nodeForStartPos.parent.parent.kind === 206 && nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { - // Use parent module declarations name for start pos nodeForStartPos = nodeForStartPos.parent.parent.name; } else { - // We have to use this name for start pos break; } } else { - // Is not a member expression so we have found the node for start pos break; } } return ts.createTextSpanFromBounds(nodeForStartPos.getStart(), node.getEnd()); } function getBreakpointStatementAtPosition(fileName, position) { - // doesn't use compiler - no need to synchronize with host var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.BreakpointResolver.spanInSourceFileAtLocation(sourceFile, position); } @@ -40489,7 +34386,7 @@ var ts; var typeChecker = program.getTypeChecker(); var result = []; processNode(sourceFile); - return { spans: result, endOfLineState: 0 /* None */ }; + return { spans: result, endOfLineState: 0 }; function pushClassification(start, length, type) { result.push(start); result.push(length); @@ -40497,46 +34394,39 @@ var ts; } function classifySymbol(symbol, meaningAtPosition) { var flags = symbol.getFlags(); - if (flags & 32 /* Class */) { - return 11 /* className */; + if (flags & 32) { + return 11; } - else if (flags & 384 /* Enum */) { - return 12 /* enumName */; + else if (flags & 384) { + return 12; } - else if (flags & 524288 /* TypeAlias */) { - return 16 /* typeAliasName */; + else if (flags & 524288) { + return 16; } - else if (meaningAtPosition & 2 /* Type */) { - if (flags & 64 /* Interface */) { - return 13 /* interfaceName */; + else if (meaningAtPosition & 2) { + if (flags & 64) { + return 13; } - else if (flags & 262144 /* TypeParameter */) { - return 15 /* typeParameterName */; + else if (flags & 262144) { + return 15; } } - else if (flags & 1536 /* Module */) { - // Only classify a module as such if - // - It appears in a namespace context. - // - There exists a module declaration which actually impacts the value side. - if (meaningAtPosition & 4 /* Namespace */ || - (meaningAtPosition & 1 /* Value */ && hasValueSideModule(symbol))) { - return 14 /* moduleName */; + else if (flags & 1536) { + if (meaningAtPosition & 4 || + (meaningAtPosition & 1 && hasValueSideModule(symbol))) { + return 14; } } return undefined; - /** - * Returns true if there exists a module that introduces entities on the value side. - */ function hasValueSideModule(symbol) { return ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 206 /* ModuleDeclaration */ && ts.getModuleInstanceState(declaration) == 1 /* Instantiated */; + return declaration.kind === 206 && ts.getModuleInstanceState(declaration) == 1; }); } } function processNode(node) { - // Only walk into nodes that intersect the requested span. if (node && ts.textSpanIntersectsWith(span, node.getStart(), node.getWidth())) { - if (node.kind === 65 /* Identifier */ && node.getWidth() > 0) { + if (node.kind === 65 && node.getWidth() > 0) { var symbol = typeChecker.getSymbolAtLocation(node); if (symbol) { var type = classifySymbol(symbol, getMeaningFromLocation(node)); @@ -40551,22 +34441,22 @@ var ts; } function getClassificationTypeName(type) { switch (type) { - case 1 /* comment */: return ClassificationTypeNames.comment; - case 2 /* identifier */: return ClassificationTypeNames.identifier; - case 3 /* keyword */: return ClassificationTypeNames.keyword; - case 4 /* numericLiteral */: return ClassificationTypeNames.numericLiteral; - case 5 /* operator */: return ClassificationTypeNames.operator; - case 6 /* stringLiteral */: return ClassificationTypeNames.stringLiteral; - case 8 /* whiteSpace */: return ClassificationTypeNames.whiteSpace; - case 9 /* text */: return ClassificationTypeNames.text; - case 10 /* punctuation */: return ClassificationTypeNames.punctuation; - case 11 /* className */: return ClassificationTypeNames.className; - case 12 /* enumName */: return ClassificationTypeNames.enumName; - case 13 /* interfaceName */: return ClassificationTypeNames.interfaceName; - case 14 /* moduleName */: return ClassificationTypeNames.moduleName; - case 15 /* typeParameterName */: return ClassificationTypeNames.typeParameterName; - case 16 /* typeAliasName */: return ClassificationTypeNames.typeAliasName; - case 17 /* parameterName */: return ClassificationTypeNames.parameterName; + case 1: return ClassificationTypeNames.comment; + case 2: return ClassificationTypeNames.identifier; + case 3: return ClassificationTypeNames.keyword; + case 4: return ClassificationTypeNames.numericLiteral; + case 5: return ClassificationTypeNames.operator; + case 6: return ClassificationTypeNames.stringLiteral; + case 8: return ClassificationTypeNames.whiteSpace; + case 9: return ClassificationTypeNames.text; + case 10: return ClassificationTypeNames.punctuation; + case 11: return ClassificationTypeNames.className; + case 12: return ClassificationTypeNames.enumName; + case 13: return ClassificationTypeNames.interfaceName; + case 14: return ClassificationTypeNames.moduleName; + case 15: return ClassificationTypeNames.typeParameterName; + case 16: return ClassificationTypeNames.typeAliasName; + case 17: return ClassificationTypeNames.parameterName; } } function convertClassifications(classifications) { @@ -40585,14 +34475,12 @@ var ts; return convertClassifications(getEncodedSyntacticClassifications(fileName, span)); } function getEncodedSyntacticClassifications(fileName, span) { - // doesn't use compiler - no need to synchronize with host var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - // Make a scanner we can get trivia from. - var triviaScanner = ts.createScanner(2 /* Latest */, false, sourceFile.text); - var mergeConflictScanner = ts.createScanner(2 /* Latest */, false, sourceFile.text); + var triviaScanner = ts.createScanner(2, false, sourceFile.text); + var mergeConflictScanner = ts.createScanner(2, false, sourceFile.text); var result = []; processElement(sourceFile); - return { spans: result, endOfLineState: 0 /* None */ }; + return { spans: result, endOfLineState: 0 }; function pushClassification(start, length, type) { result.push(start); result.push(length); @@ -40603,7 +34491,6 @@ var ts; if (tokenStart === token.pos) { return; } - // token has trivia. Classify them appropriately. triviaScanner.setTextPos(token.pos); while (true) { var start = triviaScanner.getTextPos(); @@ -40615,36 +34502,29 @@ var ts; return; } if (ts.isComment(kind)) { - // Simple comment. Just add as is. - pushClassification(start, width, 1 /* comment */); + pushClassification(start, width, 1); continue; } - if (kind === 6 /* ConflictMarkerTrivia */) { + if (kind === 6) { var text = sourceFile.text; var ch = text.charCodeAt(start); - // for the <<<<<<< and >>>>>>> markers, we just add them in as comments - // in the classification stream. - if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) { - pushClassification(start, width, 1 /* comment */); + if (ch === 60 || ch === 62) { + pushClassification(start, width, 1); continue; } - // for the ======== add a comment for the first line, and then lex all - // subsequent lines up until the end of the conflict marker. - ts.Debug.assert(ch === 61 /* equals */); + ts.Debug.assert(ch === 61); classifyDisabledMergeCode(text, start, end); } } } } function classifyDisabledMergeCode(text, start, end) { - // Classify the line that the ======= marker is on as a comment. Then just lex - // all further tokens and add them to the result. for (var i = start; i < end; i++) { if (ts.isLineBreak(text.charCodeAt(i))) { break; } } - pushClassification(start, i - start, 1 /* comment */); + pushClassification(start, i - start, 1); mergeConflictScanner.setTextPos(i); while (mergeConflictScanner.getTextPos() < end) { classifyDisabledCodeToken(); @@ -40668,95 +34548,84 @@ var ts; } } } - // for accurate classification, the actual token should be passed in. however, for - // cases like 'disabled merge code' classification, we just get the token kind and - // classify based on that instead. function classifyTokenType(tokenKind, token) { if (ts.isKeyword(tokenKind)) { - return 3 /* keyword */; + return 3; } - // Special case < and > If they appear in a generic context they are punctuation, - // not operators. - if (tokenKind === 24 /* LessThanToken */ || tokenKind === 25 /* GreaterThanToken */) { - // If the node owning the token has a type argument list or type parameter list, then - // we can effectively assume that a '<' and '>' belong to those lists. + if (tokenKind === 24 || tokenKind === 25) { if (token && ts.getTypeArgumentOrTypeParameterList(token.parent)) { - return 10 /* punctuation */; + return 10; } } if (ts.isPunctuation(tokenKind)) { if (token) { - if (tokenKind === 53 /* EqualsToken */) { - // the '=' in a variable declaration is special cased here. - if (token.parent.kind === 199 /* VariableDeclaration */ || - token.parent.kind === 133 /* PropertyDeclaration */ || - token.parent.kind === 130 /* Parameter */) { - return 5 /* operator */; + if (tokenKind === 53) { + if (token.parent.kind === 199 || + token.parent.kind === 133 || + token.parent.kind === 130) { + return 5; } } - if (token.parent.kind === 170 /* BinaryExpression */ || - token.parent.kind === 168 /* PrefixUnaryExpression */ || - token.parent.kind === 169 /* PostfixUnaryExpression */ || - token.parent.kind === 171 /* ConditionalExpression */) { - return 5 /* operator */; + if (token.parent.kind === 170 || + token.parent.kind === 168 || + token.parent.kind === 169 || + token.parent.kind === 171) { + return 5; } } - return 10 /* punctuation */; + return 10; } - else if (tokenKind === 7 /* NumericLiteral */) { - return 4 /* numericLiteral */; + else if (tokenKind === 7) { + return 4; } - else if (tokenKind === 8 /* StringLiteral */) { - return 6 /* stringLiteral */; + else if (tokenKind === 8) { + return 6; } - else if (tokenKind === 9 /* RegularExpressionLiteral */) { - // TODO: we should get another classification type for these literals. - return 6 /* stringLiteral */; + else if (tokenKind === 9) { + return 6; } else if (ts.isTemplateLiteralKind(tokenKind)) { - // TODO (drosen): we should *also* get another classification type for these literals. - return 6 /* stringLiteral */; + return 6; } - else if (tokenKind === 65 /* Identifier */) { + else if (tokenKind === 65) { if (token) { switch (token.parent.kind) { - case 202 /* ClassDeclaration */: + case 202: if (token.parent.name === token) { - return 11 /* className */; + return 11; } return; - case 129 /* TypeParameter */: + case 129: if (token.parent.name === token) { - return 15 /* typeParameterName */; + return 15; } return; - case 203 /* InterfaceDeclaration */: + case 203: if (token.parent.name === token) { - return 13 /* interfaceName */; + return 13; } return; - case 205 /* EnumDeclaration */: + case 205: if (token.parent.name === token) { - return 12 /* enumName */; + return 12; } return; - case 206 /* ModuleDeclaration */: + case 206: if (token.parent.name === token) { - return 14 /* moduleName */; + return 14; } return; - case 130 /* Parameter */: + case 130: if (token.parent.name === token) { - return 17 /* parameterName */; + return 17; } return; } } - return 9 /* text */; + return 9; } } function processElement(element) { - // Ignore nodes that don't intersect the original span to classify. if (ts.textSpanIntersectsWith(span, element.getFullStart(), element.getFullWidth())) { var children = element.getChildren(); for (var _i = 0; _i < children.length; _i++) { @@ -40765,7 +34634,6 @@ var ts; classifyToken(child); } else { - // Recurse into our child nodes. processElement(child); } } @@ -40773,7 +34641,6 @@ var ts; } } function getOutliningSpans(fileName) { - // doesn't use compiler - no need to synchronize with host var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.OutliningElementsCollector.collectElements(sourceFile); } @@ -40783,7 +34650,6 @@ var ts; var token = ts.getTouchingToken(sourceFile, position); if (token.getStart(sourceFile) === position) { var matchKind = getMatchingTokenKind(token); - // Ensure that there is a corresponding token to match ours. if (matchKind) { var parentElement = token.parent; var childNodes = parentElement.getChildren(sourceFile); @@ -40792,7 +34658,6 @@ var ts; if (current.kind === matchKind) { var range1 = ts.createTextSpan(token.getStart(sourceFile), token.getWidth(sourceFile)); var range2 = ts.createTextSpan(current.getStart(sourceFile), current.getWidth(sourceFile)); - // We want to order the braces when we return the result. if (range1.start < range2.start) { result.push(range1, range2); } @@ -40807,14 +34672,14 @@ var ts; return result; function getMatchingTokenKind(token) { switch (token.kind) { - case 14 /* OpenBraceToken */: return 15 /* CloseBraceToken */; - case 16 /* OpenParenToken */: return 17 /* CloseParenToken */; - case 18 /* OpenBracketToken */: return 19 /* CloseBracketToken */; - case 24 /* LessThanToken */: return 25 /* GreaterThanToken */; - case 15 /* CloseBraceToken */: return 14 /* OpenBraceToken */; - case 17 /* CloseParenToken */: return 16 /* OpenParenToken */; - case 19 /* CloseBracketToken */: return 18 /* OpenBracketToken */; - case 25 /* GreaterThanToken */: return 24 /* LessThanToken */; + case 14: return 15; + case 16: return 17; + case 18: return 19; + case 24: return 25; + case 15: return 14; + case 17: return 16; + case 19: return 18; + case 25: return 24; } return undefined; } @@ -40850,12 +34715,6 @@ var ts; return []; } function getTodoComments(fileName, descriptors) { - // Note: while getting todo comments seems like a syntactic operation, we actually - // treat it as a semantic operation here. This is because we expect our host to call - // this on every single file. If we treat this syntactically, then that will cause - // us to populate and throw away the tree in our syntax tree cache for each file. By - // treating this as a semantic operation, we can access any tree without throwing - // anything away. synchronizeHostData(); var sourceFile = getValidSourceFile(fileName); cancellationToken.throwIfCancellationRequested(); @@ -40866,29 +34725,10 @@ var ts; var matchArray; while (matchArray = regExp.exec(fileContents)) { cancellationToken.throwIfCancellationRequested(); - // If we got a match, here is what the match array will look like. Say the source text is: - // - // " // hack 1" - // - // The result array with the regexp: will be: - // - // ["// hack 1", "// ", "hack 1", undefined, "hack"] - // - // Here are the relevant capture groups: - // 0) The full match for the entire regexp. - // 1) The preamble to the message portion. - // 2) The message portion. - // 3...N) The descriptor that was matched - by index. 'undefined' for each - // descriptor that didn't match. an actual value if it did match. - // - // i.e. 'undefined' in position 3 above means TODO(jason) didn't match. - // "hack" in position 4 means HACK did match. var firstDescriptorCaptureIndex = 3; ts.Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex); var preamble = matchArray[1]; var matchPosition = matchArray.index + preamble.length; - // OK, we have found a match in the file. This is only an acceptable match if - // it is contained within a comment. var token = ts.getTokenAtPosition(sourceFile, matchPosition); if (!isInsideComment(sourceFile, token, matchPosition)) { continue; @@ -40900,8 +34740,6 @@ var ts; } } ts.Debug.assert(descriptor !== undefined); - // We don't want to match something like 'TODOBY', so we make sure a non - // letter/digit follows the match. if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) { continue; } @@ -40920,57 +34758,21 @@ var ts; function getTodoCommentsRegExp() { // NOTE: ?: means 'non-capture group'. It allows us to have groups without having to // filter them out later in the final result array. - // TODO comments can appear in one of the following forms: - // - // 1) // TODO or /////////// TODO - // - // 2) /* TODO or /********** TODO - // - // 3) /* - // * TODO - // */ - // - // The following three regexps are used to match the start of the text up to the TODO - // comment portion. var singleLineCommentStart = /(?:\/\/+\s*)/.source; var multiLineCommentStart = /(?:\/\*+\s*)/.source; var anyNumberOfSpacesAndAsterixesAtStartOfLine = /(?:^(?:\s|\*)*)/.source; - // Match any of the above three TODO comment start regexps. - // Note that the outermost group *is* a capture group. We want to capture the preamble - // so that we can determine the starting position of the TODO comment match. var preamble = "(" + anyNumberOfSpacesAndAsterixesAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")"; - // Takes the descriptors and forms a regexp that matches them as if they were literals. - // For example, if the descriptors are "TODO(jason)" and "HACK", then this will be: - // - // (?:(TODO\(jason\))|(HACK)) - // - // Note that the outermost group is *not* a capture group, but the innermost groups - // *are* capture groups. By capturing the inner literals we can determine after - // matching which descriptor we are dealing with. var literals = "(?:" + ts.map(descriptors, function (d) { return "(" + escapeRegExp(d.text) + ")"; }).join("|") + ")"; - // After matching a descriptor literal, the following regexp matches the rest of the - // text up to the end of the line (or */). var endOfLineOrEndOfComment = /(?:$|\*\/)/.source; var messageRemainder = /(?:.*?)/.source; - // This is the portion of the match we'll return as part of the TODO comment result. We - // match the literal portion up to the end of the line or end of comment. var messagePortion = "(" + literals + messageRemainder + ")"; var regExpString = preamble + messagePortion + endOfLineOrEndOfComment; - // The final regexp will look like this: - // /((?:\/\/+\s*)|(?:\/\*+\s*)|(?:^(?:\s|\*)*))((?:(TODO\(jason\))|(HACK))(?:.*?))(?:$|\*\/)/gim - // The flags of the regexp are important here. - // 'g' is so that we are doing a global search and can find matches several times - // in the input. - // - // 'i' is for case insensitivity (We do this to match C# TODO comment code). - // - // 'm' is so we can find matches in a multi-line input. return new RegExp(regExpString, "gim"); } function isLetterOrDigit(char) { - return (char >= 97 /* a */ && char <= 122 /* z */) || - (char >= 65 /* A */ && char <= 90 /* Z */) || - (char >= 48 /* _0 */ && char <= 57 /* _9 */); + return (char >= 97 && char <= 122) || + (char >= 65 && char <= 90) || + (char >= 48 && char <= 57); } } function getRenameInfo(fileName, position) { @@ -40978,14 +34780,11 @@ var ts; var sourceFile = getValidSourceFile(fileName); var typeChecker = program.getTypeChecker(); var node = ts.getTouchingWord(sourceFile, position); - // Can only rename an identifier. - if (node && node.kind === 65 /* Identifier */) { + if (node && node.kind === 65) { var symbol = typeChecker.getSymbolAtLocation(node); - // Only allow a symbol to be renamed if it actually has at least one declaration. if (symbol) { var declarations = symbol.getDeclarations(); if (declarations && declarations.length > 0) { - // Disallow rename for elements that are defined in the standard TypeScript library. var defaultLibFileName = host.getDefaultLibFileName(host.getCompilationSettings()); if (defaultLibFileName) { for (var _i = 0; _i < declarations.length; _i++) { @@ -41039,6 +34838,7 @@ var ts; getSignatureHelpItems: getSignatureHelpItems, getQuickInfoAtPosition: getQuickInfoAtPosition, getDefinitionAtPosition: getDefinitionAtPosition, + getTypeDefinitionAtPosition: getTypeDefinitionAtPosition, getReferencesAtPosition: getReferencesAtPosition, findReferences: findReferences, getOccurrencesAtPosition: getOccurrencesAtPosition, @@ -41062,7 +34862,6 @@ var ts; }; } ts.createLanguageService = createLanguageService; - /* @internal */ function getNameTable(sourceFile) { if (!sourceFile.nameTable) { initializeNameTable(sourceFile); @@ -41076,17 +34875,13 @@ var ts; sourceFile.nameTable = nameTable; function walk(node) { switch (node.kind) { - case 65 /* Identifier */: + case 65: nameTable[node.text] = node.text; break; - case 8 /* StringLiteral */: - case 7 /* NumericLiteral */: - // We want to store any numbers/strings if they were a name that could be - // related to a declaration. So, if we have 'import x = require("something")' - // then we want 'something' to be in the name table. Similarly, if we have - // "a['propname']" then we want to store "propname" in the name table. + case 8: + case 7: if (ts.isDeclarationName(node) || - node.parent.kind === 220 /* ExternalModuleReference */ || + node.parent.kind === 220 || isArgumentOfElementAccessExpression(node)) { nameTable[node.text] = node.text; } @@ -41099,67 +34894,35 @@ var ts; function isArgumentOfElementAccessExpression(node) { return node && node.parent && - node.parent.kind === 157 /* ElementAccessExpression */ && + node.parent.kind === 157 && node.parent.argumentExpression === node; } - /// Classifier function createClassifier() { - var scanner = ts.createScanner(2 /* Latest */, false); - /// We do not have a full parser support to know when we should parse a regex or not - /// If we consider every slash token to be a regex, we could be missing cases like "1/2/3", where - /// we have a series of divide operator. this list allows us to be more accurate by ruling out - /// locations where a regexp cannot exist. + var scanner = ts.createScanner(2, false); var noRegexTable = []; - noRegexTable[65 /* Identifier */] = true; - noRegexTable[8 /* StringLiteral */] = true; - noRegexTable[7 /* NumericLiteral */] = true; - noRegexTable[9 /* RegularExpressionLiteral */] = true; - noRegexTable[93 /* ThisKeyword */] = true; - noRegexTable[38 /* PlusPlusToken */] = true; - noRegexTable[39 /* MinusMinusToken */] = true; - noRegexTable[17 /* CloseParenToken */] = true; - noRegexTable[19 /* CloseBracketToken */] = true; - noRegexTable[15 /* CloseBraceToken */] = true; - noRegexTable[95 /* TrueKeyword */] = true; - noRegexTable[80 /* FalseKeyword */] = true; - // Just a stack of TemplateHeads and OpenCurlyBraces, used to perform rudimentary (inexact) - // classification on template strings. Because of the context free nature of templates, - // the only precise way to classify a template portion would be by propagating the stack across - // lines, just as we do with the end-of-line state. However, this is a burden for implementers, - // and the behavior is entirely subsumed by the syntactic classifier anyway, so we instead - // flatten any nesting when the template stack is non-empty and encode it in the end-of-line state. - // Situations in which this fails are - // 1) When template strings are nested across different lines: - // `hello ${ `world - // ` }` - // - // Where on the second line, you will get the closing of a template, - // a closing curly, and a new template. - // - // 2) When substitution expressions have curly braces and the curly brace falls on the next line: - // `hello ${ () => { - // return "world" } } ` - // - // Where on the second line, you will get the 'return' keyword, - // a string literal, and a template end consisting of '} } `'. + noRegexTable[65] = true; + noRegexTable[8] = true; + noRegexTable[7] = true; + noRegexTable[9] = true; + noRegexTable[93] = true; + noRegexTable[38] = true; + noRegexTable[39] = true; + noRegexTable[17] = true; + noRegexTable[19] = true; + noRegexTable[15] = true; + noRegexTable[95] = true; + noRegexTable[80] = true; var templateStack = []; - /** Returns true if 'keyword2' can legally follow 'keyword1' in any language construct. */ function canFollow(keyword1, keyword2) { if (ts.isAccessibilityModifier(keyword1)) { - if (keyword2 === 116 /* GetKeyword */ || - keyword2 === 121 /* SetKeyword */ || - keyword2 === 114 /* ConstructorKeyword */ || - keyword2 === 109 /* StaticKeyword */) { - // Allow things like "public get", "public constructor" and "public static". - // These are all legal. + if (keyword2 === 116 || + keyword2 === 121 || + keyword2 === 114 || + keyword2 === 109) { return true; } - // Any other keyword following "public" is actually an identifier an not a real - // keyword. return false; } - // Assume any other keyword combination is legal. This can be refined in the future - // if there are more cases we want the classifier to be better at. return true; } function convertClassifications(classifications, text) { @@ -41170,7 +34933,6 @@ var ts; var start = dense[i]; var length_1 = dense[i + 1]; var type = dense[i + 2]; - // Make a whitespace entry between the last item and this one. if (lastEnd >= 0) { var whitespaceLength_1 = start - lastEnd; if (whitespaceLength_1 > 0) { @@ -41188,22 +34950,22 @@ var ts; } function convertClassification(type) { switch (type) { - case 1 /* comment */: return TokenClass.Comment; - case 3 /* keyword */: return TokenClass.Keyword; - case 4 /* numericLiteral */: return TokenClass.NumberLiteral; - case 5 /* operator */: return TokenClass.Operator; - case 6 /* stringLiteral */: return TokenClass.StringLiteral; - case 8 /* whiteSpace */: return TokenClass.Whitespace; - case 10 /* punctuation */: return TokenClass.Punctuation; - case 2 /* identifier */: - case 11 /* className */: - case 12 /* enumName */: - case 13 /* interfaceName */: - case 14 /* moduleName */: - case 15 /* typeParameterName */: - case 16 /* typeAliasName */: - case 9 /* text */: - case 17 /* parameterName */: + case 1: return TokenClass.Comment; + case 3: return TokenClass.Keyword; + case 4: return TokenClass.NumberLiteral; + case 5: return TokenClass.Operator; + case 6: return TokenClass.StringLiteral; + case 8: return TokenClass.Whitespace; + case 10: return TokenClass.Punctuation; + case 2: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 9: + case 17: default: return TokenClass.Identifier; } @@ -41211,139 +34973,95 @@ var ts; function getClassificationsForLine(text, lexState, syntacticClassifierAbsent) { return convertClassifications(getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent), text); } - // If there is a syntactic classifier ('syntacticClassifierAbsent' is false), - // we will be more conservative in order to avoid conflicting with the syntactic classifier. function getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent) { var offset = 0; - var token = 0 /* Unknown */; - var lastNonTriviaToken = 0 /* Unknown */; - // Empty out the template stack for reuse. + var token = 0; + var lastNonTriviaToken = 0; while (templateStack.length > 0) { templateStack.pop(); } - // If we're in a string literal, then prepend: "\ - // (and a newline). That way when we lex we'll think we're still in a string literal. - // - // If we're in a multiline comment, then prepend: /* - // (and a newline). That way when we lex we'll think we're still in a multiline comment. switch (lexState) { - case 3 /* InDoubleQuoteStringLiteral */: + case 3: text = '"\\\n' + text; offset = 3; break; - case 2 /* InSingleQuoteStringLiteral */: + case 2: text = "'\\\n" + text; offset = 3; break; - case 1 /* InMultiLineCommentTrivia */: + case 1: text = "/*\n" + text; offset = 3; break; - case 4 /* InTemplateHeadOrNoSubstitutionTemplate */: + case 4: text = "`\n" + text; offset = 2; break; - case 5 /* InTemplateMiddleOrTail */: + case 5: text = "}\n" + text; offset = 2; - // fallthrough - case 6 /* InTemplateSubstitutionPosition */: - templateStack.push(11 /* TemplateHead */); + case 6: + templateStack.push(11); break; } scanner.setText(text); var result = { - endOfLineState: 0 /* None */, + endOfLineState: 0, spans: [] }; - // We can run into an unfortunate interaction between the lexical and syntactic classifier - // when the user is typing something generic. Consider the case where the user types: - // - // Foo tokens. It's a weak heuristic, but should - // work well enough in practice. var angleBracketStack = 0; do { token = scanner.scan(); if (!ts.isTrivia(token)) { - if ((token === 36 /* SlashToken */ || token === 57 /* SlashEqualsToken */) && !noRegexTable[lastNonTriviaToken]) { - if (scanner.reScanSlashToken() === 9 /* RegularExpressionLiteral */) { - token = 9 /* RegularExpressionLiteral */; + if ((token === 36 || token === 57) && !noRegexTable[lastNonTriviaToken]) { + if (scanner.reScanSlashToken() === 9) { + token = 9; } } - else if (lastNonTriviaToken === 20 /* DotToken */ && isKeyword(token)) { - token = 65 /* Identifier */; + else if (lastNonTriviaToken === 20 && isKeyword(token)) { + token = 65; } else if (isKeyword(lastNonTriviaToken) && isKeyword(token) && !canFollow(lastNonTriviaToken, token)) { - // We have two keywords in a row. Only treat the second as a keyword if - // it's a sequence that could legally occur in the language. Otherwise - // treat it as an identifier. This way, if someone writes "private var" - // we recognize that 'var' is actually an identifier here. - token = 65 /* Identifier */; - } - else if (lastNonTriviaToken === 65 /* Identifier */ && - token === 24 /* LessThanToken */) { - // Could be the start of something generic. Keep track of that by bumping - // up the current count of generic contexts we may be in. + token = 65; + } + else if (lastNonTriviaToken === 65 && + token === 24) { angleBracketStack++; } - else if (token === 25 /* GreaterThanToken */ && angleBracketStack > 0) { - // If we think we're currently in something generic, then mark that that - // generic entity is complete. + else if (token === 25 && angleBracketStack > 0) { angleBracketStack--; } - else if (token === 112 /* AnyKeyword */ || - token === 122 /* StringKeyword */ || - token === 120 /* NumberKeyword */ || - token === 113 /* BooleanKeyword */ || - token === 123 /* SymbolKeyword */) { + else if (token === 112 || + token === 122 || + token === 120 || + token === 113 || + token === 123) { if (angleBracketStack > 0 && !syntacticClassifierAbsent) { - // If it looks like we're could be in something generic, don't classify this - // as a keyword. We may just get overwritten by the syntactic classifier, - // causing a noisy experience for the user. - token = 65 /* Identifier */; + token = 65; } } - else if (token === 11 /* TemplateHead */) { + else if (token === 11) { templateStack.push(token); } - else if (token === 14 /* OpenBraceToken */) { - // If we don't have anything on the template stack, - // then we aren't trying to keep track of a previously scanned template head. + else if (token === 14) { if (templateStack.length > 0) { templateStack.push(token); } } - else if (token === 15 /* CloseBraceToken */) { - // If we don't have anything on the template stack, - // then we aren't trying to keep track of a previously scanned template head. + else if (token === 15) { if (templateStack.length > 0) { var lastTemplateStackToken = ts.lastOrUndefined(templateStack); - if (lastTemplateStackToken === 11 /* TemplateHead */) { + if (lastTemplateStackToken === 11) { token = scanner.reScanTemplateToken(); - // Only pop on a TemplateTail; a TemplateMiddle indicates there is more for us. - if (token === 13 /* TemplateTail */) { + if (token === 13) { templateStack.pop(); } else { - ts.Debug.assert(token === 12 /* TemplateMiddle */, "Should have been a template middle. Was " + token); + ts.Debug.assert(token === 12, "Should have been a template middle. Was " + token); } } else { - ts.Debug.assert(lastTemplateStackToken === 14 /* OpenBraceToken */, "Should have been an open brace. Was: " + token); + ts.Debug.assert(lastTemplateStackToken === 14, "Should have been an open brace. Was: " + token); templateStack.pop(); } } @@ -41351,68 +35069,59 @@ var ts; lastNonTriviaToken = token; } processToken(); - } while (token !== 1 /* EndOfFileToken */); + } while (token !== 1); return result; function processToken() { var start = scanner.getTokenPos(); var end = scanner.getTextPos(); addResult(start, end, classFromKind(token)); if (end >= text.length) { - if (token === 8 /* StringLiteral */) { - // Check to see if we finished up on a multiline string literal. + if (token === 8) { var tokenText = scanner.getTokenText(); if (scanner.isUnterminated()) { var lastCharIndex = tokenText.length - 1; var numBackslashes = 0; - while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === 92 /* backslash */) { + while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === 92) { numBackslashes++; } - // If we have an odd number of backslashes, then the multiline string is unclosed if (numBackslashes & 1) { var quoteChar = tokenText.charCodeAt(0); - result.endOfLineState = quoteChar === 34 /* doubleQuote */ - ? 3 /* InDoubleQuoteStringLiteral */ - : 2 /* InSingleQuoteStringLiteral */; + result.endOfLineState = quoteChar === 34 + ? 3 + : 2; } } } - else if (token === 3 /* MultiLineCommentTrivia */) { - // Check to see if the multiline comment was unclosed. + else if (token === 3) { if (scanner.isUnterminated()) { - result.endOfLineState = 1 /* InMultiLineCommentTrivia */; + result.endOfLineState = 1; } } else if (ts.isTemplateLiteralKind(token)) { if (scanner.isUnterminated()) { - if (token === 13 /* TemplateTail */) { - result.endOfLineState = 5 /* InTemplateMiddleOrTail */; + if (token === 13) { + result.endOfLineState = 5; } - else if (token === 10 /* NoSubstitutionTemplateLiteral */) { - result.endOfLineState = 4 /* InTemplateHeadOrNoSubstitutionTemplate */; + else if (token === 10) { + result.endOfLineState = 4; } else { ts.Debug.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + token); } } } - else if (templateStack.length > 0 && ts.lastOrUndefined(templateStack) === 11 /* TemplateHead */) { - result.endOfLineState = 6 /* InTemplateSubstitutionPosition */; + else if (templateStack.length > 0 && ts.lastOrUndefined(templateStack) === 11) { + result.endOfLineState = 6; } } } function addResult(start, end, classification) { - if (classification === 8 /* whiteSpace */) { - // Don't bother with whitespace classifications. They're not needed. + if (classification === 8) { return; } if (start === 0 && offset > 0) { - // We're classifying the first token, and this was a case where we prepended - // text. We should consider the start of this token to be at the start of - // the original text. start += offset; } - // All our tokens are in relation to the augmented text. Move them back to be - // relative to the original text. start -= offset; end -= offset; var length = end - start; @@ -41425,42 +35134,42 @@ var ts; } function isBinaryExpressionOperatorToken(token) { switch (token) { - case 35 /* AsteriskToken */: - case 36 /* SlashToken */: - case 37 /* PercentToken */: - case 33 /* PlusToken */: - case 34 /* MinusToken */: - case 40 /* LessThanLessThanToken */: - case 41 /* GreaterThanGreaterThanToken */: - case 42 /* GreaterThanGreaterThanGreaterThanToken */: - case 24 /* LessThanToken */: - case 25 /* GreaterThanToken */: - case 26 /* LessThanEqualsToken */: - case 27 /* GreaterThanEqualsToken */: - case 87 /* InstanceOfKeyword */: - case 86 /* InKeyword */: - case 28 /* EqualsEqualsToken */: - case 29 /* ExclamationEqualsToken */: - case 30 /* EqualsEqualsEqualsToken */: - case 31 /* ExclamationEqualsEqualsToken */: - case 43 /* AmpersandToken */: - case 45 /* CaretToken */: - case 44 /* BarToken */: - case 48 /* AmpersandAmpersandToken */: - case 49 /* BarBarToken */: - case 63 /* BarEqualsToken */: - case 62 /* AmpersandEqualsToken */: - case 64 /* CaretEqualsToken */: - case 59 /* LessThanLessThanEqualsToken */: - case 60 /* GreaterThanGreaterThanEqualsToken */: - case 61 /* GreaterThanGreaterThanGreaterThanEqualsToken */: - case 54 /* PlusEqualsToken */: - case 55 /* MinusEqualsToken */: - case 56 /* AsteriskEqualsToken */: - case 57 /* SlashEqualsToken */: - case 58 /* PercentEqualsToken */: - case 53 /* EqualsToken */: - case 23 /* CommaToken */: + case 35: + case 36: + case 37: + case 33: + case 34: + case 40: + case 41: + case 42: + case 24: + case 25: + case 26: + case 27: + case 87: + case 86: + case 28: + case 29: + case 30: + case 31: + case 43: + case 45: + case 44: + case 48: + case 49: + case 63: + case 62: + case 64: + case 59: + case 60: + case 61: + case 54: + case 55: + case 56: + case 57: + case 58: + case 53: + case 23: return true; default: return false; @@ -41468,50 +35177,50 @@ var ts; } function isPrefixUnaryExpressionOperatorToken(token) { switch (token) { - case 33 /* PlusToken */: - case 34 /* MinusToken */: - case 47 /* TildeToken */: - case 46 /* ExclamationToken */: - case 38 /* PlusPlusToken */: - case 39 /* MinusMinusToken */: + case 33: + case 34: + case 47: + case 46: + case 38: + case 39: return true; default: return false; } } function isKeyword(token) { - return token >= 66 /* FirstKeyword */ && token <= 126 /* LastKeyword */; + return token >= 66 && token <= 126; } function classFromKind(token) { if (isKeyword(token)) { - return 3 /* keyword */; + return 3; } else if (isBinaryExpressionOperatorToken(token) || isPrefixUnaryExpressionOperatorToken(token)) { - return 5 /* operator */; + return 5; } - else if (token >= 14 /* FirstPunctuation */ && token <= 64 /* LastPunctuation */) { - return 10 /* punctuation */; + else if (token >= 14 && token <= 64) { + return 10; } switch (token) { - case 7 /* NumericLiteral */: - return 4 /* numericLiteral */; - case 8 /* StringLiteral */: - return 6 /* stringLiteral */; - case 9 /* RegularExpressionLiteral */: - return 7 /* regularExpressionLiteral */; - case 6 /* ConflictMarkerTrivia */: - case 3 /* MultiLineCommentTrivia */: - case 2 /* SingleLineCommentTrivia */: - return 1 /* comment */; - case 5 /* WhitespaceTrivia */: - case 4 /* NewLineTrivia */: - return 8 /* whiteSpace */; - case 65 /* Identifier */: + case 7: + return 4; + case 8: + return 6; + case 9: + return 7; + case 6: + case 3: + case 2: + return 1; + case 5: + case 4: + return 8; + case 65: default: if (ts.isTemplateLiteralKind(token)) { - return 6 /* stringLiteral */; + return 6; } - return 2 /* identifier */; + return 2; } } return { @@ -41520,13 +35229,7 @@ var ts; }; } ts.createClassifier = createClassifier; - /** - * Get the path of the default library file (lib.d.ts) as distributed with the typescript - * node package. - * The functionality is not supported if the ts module is consumed outside of a node module. - */ function getDefaultLibFilePath(options) { - // Check __dirname is defined and that we are on a node.js system. if (typeof __dirname !== "undefined") { return __dirname + ts.directorySeparator + ts.getDefaultLibFileName(options); } @@ -41538,7 +35241,7 @@ var ts; getNodeConstructor: function (kind) { function Node() { } - var proto = kind === 228 /* SourceFile */ ? new SourceFileObject() : new NodeObject(); + var proto = kind === 228 ? new SourceFileObject() : new NodeObject(); proto.kind = kind; proto.pos = 0; proto.end = 0; @@ -41639,6 +35342,7 @@ var ts; CommandNames.Rename = "rename"; CommandNames.Saveto = "saveto"; CommandNames.SignatureHelp = "signatureHelp"; + CommandNames.TypeDefinition = "typeDefinition"; CommandNames.Unknown = "unknown"; })(CommandNames = server.CommandNames || (server.CommandNames = {})); var Errors; @@ -41810,6 +35514,24 @@ var ts; end: compilerService.host.positionToLineOffset(def.fileName, ts.textSpanEnd(def.textSpan)) }); }); }; + Session.prototype.getTypeDefinition = function (line, offset, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineOffsetToPosition(file, line, offset); + var definitions = compilerService.languageService.getTypeDefinitionAtPosition(file, position); + if (!definitions) { + return undefined; + } + return definitions.map(function (def) { return ({ + file: def.fileName, + start: compilerService.host.positionToLineOffset(def.fileName, def.textSpan.start), + end: compilerService.host.positionToLineOffset(def.fileName, ts.textSpanEnd(def.textSpan)) + }); }); + }; Session.prototype.getOccurrences = function (line, offset, fileName) { fileName = ts.normalizePath(fileName); var project = this.projectService.getProjectForFile(fileName); @@ -41868,7 +35590,6 @@ var ts; return 1; } else { - // reverse sort assuming no overlap if (a.start.line < b.start.line) { return 1; } @@ -41897,8 +35618,6 @@ var ts; return { info: renameInfo, locs: bakedRenameLocs }; }; Session.prototype.getReferences = function (line, offset, fileName) { - // TODO: get all projects for this file; report refs for all projects deleting duplicates - // can avoid duplicates by eliminating same ref file from subsequent projects var file = ts.normalizePath(fileName); var project = this.projectService.getProjectForFile(file); if (!project) { @@ -41974,7 +35693,6 @@ var ts; var compilerService = project.compilerService; var startPosition = compilerService.host.lineOffsetToPosition(file, line, offset); var endPosition = compilerService.host.lineOffsetToPosition(file, endLine, endOffset); - // TODO: avoid duplicate code (with formatonkey) var edits = compilerService.languageService.getFormattingEditsForRange(file, startPosition, endPosition, this.projectService.getFormatCodeOptions(file)); if (!edits) { return undefined; @@ -41997,12 +35715,6 @@ var ts; var position = compilerService.host.lineOffsetToPosition(file, line, offset); var formatOptions = this.projectService.getFormatCodeOptions(file); var edits = compilerService.languageService.getFormattingEditsAfterKeystroke(file, position, key, formatOptions); - // Check whether we should auto-indent. This will be when - // the position is on a line containing only whitespace. - // This should leave the edits returned from - // getFormattingEditsAfterKeytroke either empty or pertaining - // only to the previous line. If all this is true, then - // add edits necessary to properly indent the current line. if ((key == "\n") && ((!edits) || (edits.length == 0) || allEditsBeforePos(edits, position))) { var scriptInfo = compilerService.host.getScriptInfo(file); if (scriptInfo) { @@ -42010,7 +35722,6 @@ var ts; if (lineInfo && (lineInfo.leaf) && (lineInfo.leaf.text)) { var lineText = lineInfo.leaf.text; if (lineText.search("\\S") < 0) { - // TODO: get these options from host var editorOptions = { IndentSize: formatOptions.IndentSize, TabSize: formatOptions.TabSize, @@ -42154,7 +35865,6 @@ var ts; var project = this.projectService.getProjectForFile(file); if (project) { this.changeSeq++; - // make sure no changes happen before this one is finished project.compilerService.host.reloadScript(file, tmpfile, function () { _this.output(undefined, CommandNames.Reload, reqSeq); }); @@ -42278,6 +35988,11 @@ var ts; response = this.getDefinition(defArgs.line, defArgs.offset, defArgs.file); break; } + case CommandNames.TypeDefinition: { + var defArgs = request.arguments; + response = this.getTypeDefinition(defArgs.line, defArgs.offset, defArgs.file); + break; + } case CommandNames.References: { var refArgs = request.arguments; response = this.getReferences(refArgs.line, refArgs.offset, refArgs.file); @@ -42444,7 +36159,7 @@ var ts; this.fileName = fileName; this.content = content; this.isOpen = isOpen; - this.children = []; // files referenced by this file + this.children = []; this.formatCodeOptions = ts.clone(CompilerService.defaultFormatCodeOptions); this.svc = ScriptVersionCache.fromString(content); } @@ -42511,7 +36226,6 @@ var ts; } }; LSHost.prototype.getCompilationSettings = function () { - // change this to return active project settings for file return this.compilationSettings; }; LSHost.prototype.getScriptFileNames = function () { @@ -42584,9 +36298,6 @@ var ts; LSHost.prototype.directoryExists = function (path) { return this.host.directoryExists(path); }; - /** - * @param line 1 based index - */ LSHost.prototype.lineToTextSpan = function (filename, line) { var script = this.filenameToScript[filename]; var index = script.snap().index; @@ -42601,21 +36312,12 @@ var ts; } return ts.createTextSpan(lineInfo.offset, len); }; - /** - * @param line 1 based index - * @param offset 1 based index - */ LSHost.prototype.lineOffsetToPosition = function (filename, line, offset) { var script = this.filenameToScript[filename]; var index = script.snap().index; var lineInfo = index.lineNumberToInfo(line); - // TODO: assert this offset is actually on the line return (lineInfo.offset + offset - 1); }; - /** - * @param line 1-based index - * @param offset 1-based index - */ LSHost.prototype.positionToLineOffset = function (filename, position) { var script = this.filenameToScript[filename]; var index = script.snap().index; @@ -42624,7 +36326,6 @@ var ts; }; return LSHost; })(); - // assumes normalized paths function getAbsolutePath(filename, directory) { var rootLength = ts.getRootLength(filename); if (rootLength > 0) { @@ -42655,7 +36356,6 @@ var ts; this.projectOptions = projectOptions; this.filenameToSourceFile = {}; this.updateGraphSeq = 0; - /** Used for configured projects which may have multiple open roots */ this.openRefCount = 0; this.compilerService = new CompilerService(this, projectOptions && projectOptions.compilerOptions); } @@ -42706,7 +36406,6 @@ var ts; Project.prototype.isConfiguredProject = function () { return this.projectFilename; }; - // add a root file to project Project.prototype.addRoot = function (info) { info.defaultProject = this; this.compilerService.host.addRoot(info); @@ -42740,17 +36439,11 @@ var ts; this.psLogger = psLogger; this.eventHandler = eventHandler; this.filenameToScriptInfo = {}; - // open, non-configured root files this.openFileRoots = []; - // projects built from openFileRoots this.inferredProjects = []; - // projects specified by a tsconfig.json file this.configuredProjects = []; - // open files referenced by a project this.openFilesReferenced = []; - // open files that are roots of a configured project this.openFileRootsConfigured = []; - // ts.disableIncrementalParsing = true; this.addDefaultHostConfiguration(); } ProjectService.prototype.addDefaultHostConfiguration = function () { @@ -42774,7 +36467,6 @@ var ts; this.psLogger.info("Error: got watch notification for unknown file: " + fileName); } if (!this.host.fileExists(fileName)) { - // File was deleted this.fileDeletedInFilesystem(info); } else { @@ -42873,24 +36565,17 @@ var ts; this.openFilesReferenced.push(info); } else { - // create new inferred project p with the newly opened file as root info.defaultProject = this.createInferredProject(info); var openFileRoots = []; - // for each inferred project root r for (var i = 0, len = this.openFileRoots.length; i < len; i++) { var r = this.openFileRoots[i]; - // if r referenced by the new project if (info.defaultProject.getSourceFile(r)) { - // remove project rooted at r this.inferredProjects = copyListRemovingItem(r.defaultProject, this.inferredProjects); - // put r in referenced open file list this.openFilesReferenced.push(r); - // set default project of r to the new project r.defaultProject = info.defaultProject; } else { - // otherwise, keep r as root of inferred project openFileRoots.push(r); } } @@ -42900,18 +36585,11 @@ var ts; } this.updateConfiguredProjectList(); }; - /** - * Remove this file from the set of open, non-configured files. - * @param info The file that has been closed or newly configured - * @param openedByConfig True if info has become a root of a configured project - */ ProjectService.prototype.closeOpenFile = function (info) { var openFileRoots = []; var removedProject; for (var i = 0, len = this.openFileRoots.length; i < len; i++) { - // if closed file is root of project if (info === this.openFileRoots[i]) { - // remove that project and remember it removedProject = info.defaultProject; } else { @@ -42942,21 +36620,17 @@ var ts; } var openFilesReferenced = []; var orphanFiles = []; - // for all open, referenced files f for (var i = 0, len = this.openFilesReferenced.length; i < len; i++) { var f = this.openFilesReferenced[i]; - // if f was referenced by the removed project, remember it if (f.defaultProject == removedProject) { f.defaultProject = undefined; orphanFiles.push(f); } else { - // otherwise add it back to the list of referenced files openFilesReferenced.push(f); } } this.openFilesReferenced = openFilesReferenced; - // treat orphaned files as newly opened for (var i = 0, len = orphanFiles.length; i < len; i++) { this.addOpenFile(orphanFiles[i]); } @@ -42991,10 +36665,6 @@ var ts; ProjectService.prototype.updateProjectStructure = function () { this.log("updating project structure from ...", "Info"); this.printProjects(); - // First loop through all open files that are referenced by projects but are not - // project roots. For each referenced file, see if the default project still - // references that file. If so, then just keep the file in the referenced list. - // If not, add the file to an unattached list, to be rechecked later. var openFilesReferenced = []; var unattachedOpenFiles = []; for (var i = 0, len = this.openFilesReferenced.length; i < len; i++) { @@ -43009,13 +36679,6 @@ var ts; } } this.openFilesReferenced = openFilesReferenced; - // Then, loop through all of the open files that are project roots. - // For each root file, note the project that it roots. Then see if - // any other projects newly reference the file. If zero projects - // newly reference the file, keep it as a root. If one or more - // projects newly references the file, remove its project from the - // inferred projects list (since it is no longer a root) and add - // the file to the open, referenced file list. var openFileRoots = []; for (var i = 0, len = this.openFileRoots.length; i < len; i++) { var rootFile = this.openFileRoots[i]; @@ -43026,15 +36689,11 @@ var ts; openFileRoots.push(rootFile); } else { - // remove project from inferred projects list because root captured this.inferredProjects = copyListRemovingItem(rootedProject, this.inferredProjects); this.openFilesReferenced.push(rootFile); } } this.openFileRoots = openFileRoots; - // Finally, if we found any open, referenced files that are no longer - // referenced by their default project, treat them as newly opened - // by the editor. for (var i = 0, len = unattachedOpenFiles.length; i < len; i++) { this.addOpenFile(unattachedOpenFiles[i]); } @@ -43044,9 +36703,6 @@ var ts; filename = ts.normalizePath(filename); return ts.lookUp(this.filenameToScriptInfo, filename); }; - /** - * @param filename is absolute pathname - */ ProjectService.prototype.openFile = function (fileName, openedByClient) { var _this = this; fileName = ts.normalizePath(fileName); @@ -43078,15 +36734,10 @@ var ts; } return info; }; - // This is different from the method the compiler uses because - // the compiler can assume it will always start searching in the - // current directory (the directory in which tsc was invoked). - // The server must start searching from the directory containing - // the newly opened file. ProjectService.prototype.findConfigFile = function (searchPath) { while (true) { var fileName = ts.combinePaths(searchPath, "tsconfig.json"); - if (ts.sys.fileExists(fileName)) { + if (this.host.fileExists(fileName)) { return fileName; } var parentPath = ts.getDirectoryPath(searchPath); @@ -43097,10 +36748,6 @@ var ts; } return undefined; }; - /** - * Open file whose contents is managed by the client - * @param filename is absolute pathname - */ ProjectService.prototype.openClientFile = function (fileName) { var searchPath = ts.normalizePath(ts.getDirectoryPath(fileName)); this.log("Search path: " + searchPath, "Info"); @@ -43129,10 +36776,6 @@ var ts; this.printProjects(); return info; }; - /** - * Close file whose contents is managed by the client - * @param filename is absolute pathname - */ ProjectService.prototype.closeClientFile = function (filename) { var info = ts.lookUp(this.filenameToScriptInfo, filename); if (info) { @@ -43209,7 +36852,6 @@ var ts; }; ProjectService.prototype.openConfigFile = function (configFilename, clientFileName) { configFilename = ts.normalizePath(configFilename); - // file references will be relative to dirPath (or absolute) var dirPath = ts.getDirectoryPath(configFilename); var rawConfig = ts.readConfigFile(configFilename); if (!rawConfig) { @@ -43228,7 +36870,7 @@ var ts; var proj = this.createProject(configFilename, projectOptions); for (var i = 0, len = parsedCommandLine.fileNames.length; i < len; i++) { var rootFilename = parsedCommandLine.fileNames[i]; - if (ts.sys.fileExists(rootFilename)) { + if (this.host.fileExists(rootFilename)) { var info = this.openFile(rootFilename, clientFileName == rootFilename); proj.addRoot(info); } @@ -43356,7 +36998,6 @@ var ts; if (lastZeroCount) { branchParent.remove(lastZeroCount); } - // path at least length two (root and leaf) var insertionNode = this.startPath[this.startPath.length - 2]; var leafNode = this.startPath[this.startPath.length - 1]; var len = lines.length; @@ -43392,7 +37033,6 @@ var ts; } } else { - // no content for leaf node, so delete it insertionNode.remove(leafNode); for (var j = this.startPath.length - 2; j >= 0; j--) { this.startPath[j].updateCounts(); @@ -43401,20 +37041,15 @@ var ts; return this.lineIndex; }; EditWalker.prototype.post = function (relativeStart, relativeLength, lineCollection, parent, nodeType) { - // have visited the path for start of range, now looking for end - // if range is on single line, we will never make this state transition if (lineCollection == this.lineCollectionAtBranch) { this.state = CharRangeSection.End; } - // always pop stack because post only called when child has been visited this.stack.length--; return undefined; }; EditWalker.prototype.pre = function (relativeStart, relativeLength, lineCollection, parent, nodeType) { - // currentNode corresponds to parent, but in the new tree var currentNode = this.stack[this.stack.length - 1]; if ((this.state == CharRangeSection.Entire) && (nodeType == CharRangeSection.Start)) { - // if range is on single line, we will never make this state transition this.state = CharRangeSection.Start; this.branchNode = currentNode; this.lineCollectionAtBranch = lineCollection; @@ -43485,7 +37120,6 @@ var ts; } return lineCollection; }; - // just gather text from the leaves EditWalker.prototype.leaf = function (relativeStart, relativeLength, ll) { if (this.state == CharRangeSection.Start) { this.initialText = ll.text.substring(0, relativeStart); @@ -43495,13 +37129,11 @@ var ts; this.trailingText = ll.text.substring(relativeStart + relativeLength); } else { - // state is CharRangeSection.End this.trailingText = ll.text.substring(relativeStart + relativeLength); } }; return EditWalker; })(BaseLineIndexWalker); - // text change information var TextChange = (function () { function TextChange(pos, deleteLen, insertedText) { this.pos = pos; @@ -43517,10 +37149,9 @@ var ts; function ScriptVersionCache() { this.changes = []; this.versions = []; - this.minVersion = 0; // no versions earlier than min version will maintain change history + this.minVersion = 0; this.currentVersion = 0; } - // REVIEW: can optimize by coalescing simple edits ScriptVersionCache.prototype.edit = function (pos, deleteLen, insertedText) { this.changes[this.changes.length] = new TextChange(pos, deleteLen, insertedText); if ((this.changes.length > ScriptVersionCache.changeNumberThreshold) || @@ -43544,16 +37175,14 @@ var ts; if (cb) cb(); }; - // reload whole script, leaving no change history behind reload ScriptVersionCache.prototype.reload = function (script) { this.currentVersion++; - this.changes = []; // history wiped out by reload + this.changes = []; var snap = new LineIndexSnapshot(this.currentVersion, this); this.versions[this.currentVersion] = snap; snap.index = new LineIndex(); var lm = LineIndex.linesFromText(script); snap.index.load(lm.lines); - // REVIEW: could use linked list for (var i = this.minVersion; i < this.currentVersion; i++) { this.versions[i] = undefined; } @@ -43631,7 +37260,6 @@ var ts; LineIndexSnapshot.prototype.getLength = function () { return this.index.root.charCount(); }; - // this requires linear space so don't hold on to these LineIndexSnapshot.prototype.getLineStartPositions = function () { var starts = [-1]; var count = 1; @@ -43665,7 +37293,6 @@ var ts; })(); var LineIndex = (function () { function LineIndex() { - // set this to true to check each edit for accuracy this.checkEdits = false; } LineIndex.prototype.charOffsetToLineNumberAndPos = function (charOffset) { @@ -43738,7 +37365,6 @@ var ts; return source.substring(0, s) + nt + source.substring(s + dl, source.length); } if (this.root.charCount() == 0) { - // TODO: assert deleteLength == 0 if (newText) { this.load(LineIndex.linesFromText(newText).lines); return this; @@ -43750,7 +37376,6 @@ var ts; } var walker = new EditWalker(); if (pos >= this.root.charCount()) { - // insert at end pos = this.root.charCount() - 1; var endString = this.getText(pos, 1); if (newText) { @@ -43763,13 +37388,10 @@ var ts; walker.suppressTrailingText = true; } else if (deleteLength > 0) { - // check whether last characters deleted are line break var e = pos + deleteLength; var lineInfo = this.charOffsetToLineNumberAndPos(e); if ((lineInfo && (lineInfo.offset == 0))) { - // move range end just past line that will merge with previous line deleteLength += lineInfo.text.length; - // store text by appending to end of insertedText if (newText) { newText = newText + lineInfo.text; } @@ -43880,11 +37502,9 @@ var ts; } }; LineNode.prototype.walk = function (rangeStart, rangeLength, walkFns) { - // assume (rangeStart < this.totalChars) && (rangeLength <= this.totalChars) var childIndex = 0; var child = this.children[0]; var childCharCount = child.charCount(); - // find sub-tree containing start var adjustedStart = rangeStart; while (adjustedStart >= childCharCount) { this.skipChild(adjustedStart, rangeLength, childIndex, walkFns, CharRangeSection.PreStart); @@ -43892,14 +37512,12 @@ var ts; child = this.children[++childIndex]; childCharCount = child.charCount(); } - // Case I: both start and end of range in same subtree if ((adjustedStart + rangeLength) <= childCharCount) { if (this.execWalk(adjustedStart, rangeLength, walkFns, childIndex, CharRangeSection.Entire)) { return; } } else { - // Case II: start and end of range in different subtrees (possibly with subtrees in the middle) if (this.execWalk(adjustedStart, childCharCount - adjustedStart, walkFns, childIndex, CharRangeSection.Start)) { return; } @@ -43920,7 +37538,6 @@ var ts; } } } - // Process any subtrees after the one containing range end if (walkFns.pre) { var clen = this.children.length; if (childIndex < (clen - 1)) { @@ -44054,7 +37671,6 @@ var ts; var childIndex = this.findChildIndex(child); var clen = this.children.length; var nodeCount = nodes.length; - // if child is last and there is more room and only one node to place, place it if ((clen < lineCollectionCapacity) && (childIndex == (clen - 1)) && (nodeCount == 1)) { this.add(nodes[0]); this.updateCounts(); @@ -44100,7 +37716,6 @@ var ts; return splitNodes; } }; - // assume there is room for the item; return true if more room LineNode.prototype.add = function (collection) { this.children[this.children.length] = collection; return (this.children.length < lineCollectionCapacity); @@ -44217,8 +37832,6 @@ var ts; return Logger; })(); var WatchedFileSet = (function () { - // average async stat takes about 30 microseconds - // set chunk size to do 30 files in < 1 millisecond function WatchedFileSet(interval, chunkSize) { if (interval === void 0) { interval = 2500; } if (chunkSize === void 0) { chunkSize = 30; } @@ -44254,9 +37867,6 @@ var ts; } }); }; - // this implementation uses polling and - // stat due to inconsistencies of fs.watch - // and efficiency of stat on modern filesystems WatchedFileSet.prototype.startWatchTimer = function () { var _this = this; this.watchTimer = setInterval(function () { @@ -44335,7 +37945,6 @@ var ts; } return logEnv; } - // TSS_LOG "{ level: "normal | verbose | terse", file?: string}" function createLoggerFromEnv() { var fileName = undefined; var detailLevel = "normal"; @@ -44354,22 +37963,7 @@ var ts; } return new Logger(fileName, detailLevel); } - // This places log file in the directory containing editorServices.js - // TODO: check that this location is writable var logger = createLoggerFromEnv(); - // REVIEW: for now this implementation uses polling. - // The advantage of polling is that it works reliably - // on all os and with network mounted files. - // For 90 referenced files, the average time to detect - // changes is 2*msInterval (by default 5 seconds). - // The overhead of this is .04 percent (1/2500) with - // average pause of < 1 millisecond (and max - // pause less than 1.5 milliseconds); question is - // do we anticipate reference sets in the 100s and - // do we care about waiting 10-20 seconds to detect - // changes for large reference sets? If so, do we want - // to increase the chunk size or decrease the interval - // time dynamically to match the large reference set? var watchedFileSet = new WatchedFileSet(); ts.sys.watchFile = function (fileName, callback) { var watchedFile = watchedFileSet.addFile(fileName, callback); @@ -44381,8 +37975,6 @@ var ts; process.on('uncaughtException', function (err) { ioSession.logError(err, "unknown"); }); - // Start listening ioSession.listen(); })(server = ts.server || (ts.server = {})); })(ts || (ts = {})); -//# sourceMappingURL=file:///C:/Users/Zhengbo/Documents/GitHub/TypeScript/built/local/tsserver.js.map \ No newline at end of file From fab273cb1fa29ea5feae462681e2cfea59fa46f0 Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Wed, 6 May 2015 10:49:07 -0700 Subject: [PATCH 2/3] Changed lib files back to 1.5 beta status. --- tsserver/lib.d.ts | 146 +----------------------------------------- tsserver/lib.es6.d.ts | 85 ++++++------------------ 2 files changed, 21 insertions(+), 210 deletions(-) diff --git a/tsserver/lib.d.ts b/tsserver/lib.d.ts index e583f1ac..5eaa933d 100644 --- a/tsserver/lib.d.ts +++ b/tsserver/lib.d.ts @@ -561,7 +561,7 @@ interface Math { */ atan(x: number): number; /** - * Returns the angle (in radians) from the X axis to a point. + * Returns the angle (in radians) from the X axis to a point (y,x). * @param y A numeric expression representing the cartesian y-coordinate. * @param x A numeric expression representing the cartesian x-coordinate. */ @@ -1231,139 +1231,6 @@ interface ArrayBufferView { byteOffset: number; } -interface DataView { - buffer: ArrayBuffer; - byteLength: number; - byteOffset: number; - /** - * Gets the Float32 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getFloat32(byteOffset: number, littleEndian: boolean): number; - - /** - * Gets the Float64 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getFloat64(byteOffset: number, littleEndian: boolean): number; - - /** - * Gets the Int8 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getInt8(byteOffset: number): number; - - /** - * Gets the Int16 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getInt16(byteOffset: number, littleEndian: boolean): number; - /** - * Gets the Int32 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getInt32(byteOffset: number, littleEndian: boolean): number; - - /** - * Gets the Uint8 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getUint8(byteOffset: number): number; - - /** - * Gets the Uint16 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getUint16(byteOffset: number, littleEndian: boolean): number; - - /** - * Gets the Uint32 value at the specified byte offset from the start of the view. There is - * no alignment constraint; multi-byte values may be fetched from any offset. - * @param byteOffset The place in the buffer at which the value should be retrieved. - */ - getUint32(byteOffset: number, littleEndian: boolean): number; - - /** - * Stores an Float32 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - * @param littleEndian If false or undefined, a big-endian value should be written, - * otherwise a little-endian value should be written. - */ - setFloat32(byteOffset: number, value: number, littleEndian: boolean): void; - - /** - * Stores an Float64 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - * @param littleEndian If false or undefined, a big-endian value should be written, - * otherwise a little-endian value should be written. - */ - setFloat64(byteOffset: number, value: number, littleEndian: boolean): void; - - /** - * Stores an Int8 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - */ - setInt8(byteOffset: number, value: number): void; - - /** - * Stores an Int16 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - * @param littleEndian If false or undefined, a big-endian value should be written, - * otherwise a little-endian value should be written. - */ - setInt16(byteOffset: number, value: number, littleEndian: boolean): void; - - /** - * Stores an Int32 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - * @param littleEndian If false or undefined, a big-endian value should be written, - * otherwise a little-endian value should be written. - */ - setInt32(byteOffset: number, value: number, littleEndian: boolean): void; - - /** - * Stores an Uint8 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - */ - setUint8(byteOffset: number, value: number): void; - - /** - * Stores an Uint16 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - * @param littleEndian If false or undefined, a big-endian value should be written, - * otherwise a little-endian value should be written. - */ - setUint16(byteOffset: number, value: number, littleEndian: boolean): void; - - /** - * Stores an Uint32 value at the specified byte offset from the start of the view. - * @param byteOffset The place in the buffer at which the value should be set. - * @param value The value to set. - * @param littleEndian If false or undefined, a big-endian value should be written, - * otherwise a little-endian value should be written. - */ - setUint32(byteOffset: number, value: number, littleEndian: boolean): void; -} - -interface DataViewConstructor { - new (buffer: ArrayBuffer, byteOffset?: number, byteLength?: number): DataView; -} -declare var DataView: DataViewConstructor; - /** * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested * number of bytes could not be allocated an exception is raised. @@ -7355,8 +7222,6 @@ interface HTMLCanvasElement extends HTMLElement { * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas. * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl"); */ - getContext(contextId: "2d"): CanvasRenderingContext2D; - getContext(contextId: "experimental-webgl"): WebGLRenderingContext; getContext(contextId: string, ...args: any[]): CanvasRenderingContext2D | WebGLRenderingContext; /** * Returns a blob object encoded as a Portable Network Graphics (PNG) format from a canvas image or drawing. @@ -15838,7 +15703,6 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget { overrideMimeType(mime: string): void; send(data?: Document): void; send(data?: string): void; - send(data?: any): void; setRequestHeader(header: string, value: string): void; DONE: number; HEADERS_RECEIVED: number; @@ -15993,13 +15857,11 @@ interface DocumentEvent { createEvent(eventInterface:"CloseEvent"): CloseEvent; createEvent(eventInterface:"CommandEvent"): CommandEvent; createEvent(eventInterface:"CompositionEvent"): CompositionEvent; - createEvent(eventInterface: "CustomEvent"): CustomEvent; createEvent(eventInterface:"DeviceMotionEvent"): DeviceMotionEvent; createEvent(eventInterface:"DeviceOrientationEvent"): DeviceOrientationEvent; createEvent(eventInterface:"DragEvent"): DragEvent; createEvent(eventInterface:"ErrorEvent"): ErrorEvent; createEvent(eventInterface:"Event"): Event; - createEvent(eventInterface:"Events"): Event; createEvent(eventInterface:"FocusEvent"): FocusEvent; createEvent(eventInterface:"GamepadEvent"): GamepadEvent; createEvent(eventInterface:"HashChangeEvent"): HashChangeEvent; @@ -16014,12 +15876,8 @@ interface DocumentEvent { createEvent(eventInterface:"MSSiteModeEvent"): MSSiteModeEvent; createEvent(eventInterface:"MessageEvent"): MessageEvent; createEvent(eventInterface:"MouseEvent"): MouseEvent; - createEvent(eventInterface:"MouseEvents"): MouseEvent; createEvent(eventInterface:"MouseWheelEvent"): MouseWheelEvent; - createEvent(eventInterface:"MSGestureEvent"): MSGestureEvent; - createEvent(eventInterface:"MSPointerEvent"): MSPointerEvent; createEvent(eventInterface:"MutationEvent"): MutationEvent; - createEvent(eventInterface:"MutationEvents"): MutationEvent; createEvent(eventInterface:"NavigationCompletedEvent"): NavigationCompletedEvent; createEvent(eventInterface:"NavigationEvent"): NavigationEvent; createEvent(eventInterface:"NavigationEventWithReferrer"): NavigationEventWithReferrer; @@ -16030,7 +15888,6 @@ interface DocumentEvent { createEvent(eventInterface:"PopStateEvent"): PopStateEvent; createEvent(eventInterface:"ProgressEvent"): ProgressEvent; createEvent(eventInterface:"SVGZoomEvent"): SVGZoomEvent; - createEvent(eventInterface:"SVGZoomEvents"): SVGZoomEvent; createEvent(eventInterface:"ScriptNotifyEvent"): ScriptNotifyEvent; createEvent(eventInterface:"StorageEvent"): StorageEvent; createEvent(eventInterface:"TextEvent"): TextEvent; @@ -16038,7 +15895,6 @@ interface DocumentEvent { createEvent(eventInterface:"TrackEvent"): TrackEvent; createEvent(eventInterface:"TransitionEvent"): TransitionEvent; createEvent(eventInterface:"UIEvent"): UIEvent; - createEvent(eventInterface:"UIEvents"): UIEvent; createEvent(eventInterface:"UnviewableContentIdentifiedEvent"): UnviewableContentIdentifiedEvent; createEvent(eventInterface:"WebGLContextEvent"): WebGLContextEvent; createEvent(eventInterface:"WheelEvent"): WheelEvent; diff --git a/tsserver/lib.es6.d.ts b/tsserver/lib.es6.d.ts index f839a3e3..297cac97 100644 --- a/tsserver/lib.es6.d.ts +++ b/tsserver/lib.es6.d.ts @@ -561,7 +561,7 @@ interface Math { */ atan(x: number): number; /** - * Returns the angle (in radians) from the X axis to a point. + * Returns the angle (in radians) from the X axis to a point (y,x). * @param y A numeric expression representing the cartesian y-coordinate. * @param x A numeric expression representing the cartesian x-coordinate. */ @@ -1237,41 +1237,11 @@ interface SymbolConstructor { isConcatSpreadable: symbol; /** - * A method that returns the default iterator for an object. Called by the semantics of the + * A method that returns the default iterator for an object.Called by the semantics of the * for-of statement. */ iterator: symbol; - /** - * A regular expression method that matches the regular expression against a string. Called - * by the String.prototype.match method. - */ - match: symbol; - - /** - * A regular expression method that replaces matched substrings of a string. Called by the - * String.prototype.replace method. - */ - replace: symbol; - - /** - * A regular expression method that returns the index within a string that matches the - * regular expression. Called by the String.prototype.search method. - */ - search: symbol; - - /** - * A function valued property that is the constructor function that is used to create - * derived objects. - */ - species: symbol; - - /** - * A regular expression method that splits a string at the indices that match the regular - * expression. Called by the String.prototype.split method. - */ - split: symbol; - /** * A method that converts an object to a corresponding primitive value.Called by the ToPrimitive * abstract operation. @@ -1658,7 +1628,7 @@ interface IteratorResult { } interface Iterator { - next(value?: any): IteratorResult; + next(): IteratorResult; return?(value?: any): IteratorResult; throw?(e?: any): IteratorResult; } @@ -4758,16 +4728,6 @@ declare module Reflect { function setPrototypeOf(target: any, proto: any): boolean; } -interface PromiseLike { - /** - * Attaches callbacks for the resolution and/or rejection of the Promise. - * @param onfulfilled The callback to execute when the Promise is resolved. - * @param onrejected The callback to execute when the Promise is rejected. - * @returns A Promise for the completion of which ever callback is executed. - */ - then(onfulfilled?: (value: T) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): PromiseLike; -} - /** * Represents the completion of an asynchronous operation */ @@ -4778,16 +4738,14 @@ interface Promise { * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of which ever callback is executed. */ - then(onfulfilled?: (value: T) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): Promise; + then(onfulfilled?: (value: T) => TResult | Promise, onrejected?: (reason: any) => TResult | Promise): Promise; /** * Attaches a callback for only the rejection of the Promise. * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of the callback. */ - catch(onrejected?: (reason: any) => T | PromiseLike): Promise; - - [Symbol.toStringTag]: string; + catch(onrejected?: (reason: any) => T | Promise): Promise; } interface PromiseConstructor { @@ -4798,11 +4756,13 @@ interface PromiseConstructor { /** * Creates a new Promise. - * @param executor A callback used to initialize the promise. This callback is passed two arguments: + * @param init A callback used to initialize the promise. This callback is passed two arguments: * a resolve callback used resolve the promise with a value or the result of another promise, * and a reject callback used to reject the promise with a provided reason or error. */ - new (executor: (resolve: (value?: T | PromiseLike) => void, reject: (reason?: any) => void) => void): Promise; + new (init: (resolve: (value?: T | Promise) => void, reject: (reason?: any) => void) => void): Promise; + + (init: (resolve: (value?: T | Promise) => void, reject: (reason?: any) => void) => void): Promise; /** * Creates a Promise that is resolved with an array of results when all of the provided Promises @@ -4810,7 +4770,15 @@ interface PromiseConstructor { * @param values An array of Promises. * @returns A new Promise. */ - all(values: Iterable>): Promise; + all(values: (T | Promise)[]): Promise; + + /** + * Creates a Promise that is resolved with an array of results when all of the provided Promises + * resolve, or rejected when any Promise is rejected. + * @param values An array of values. + * @returns A new Promise. + */ + all(values: Promise[]): Promise; /** * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved @@ -4818,7 +4786,7 @@ interface PromiseConstructor { * @param values An array of Promises. * @returns A new Promise. */ - race(values: Iterable>): Promise; + race(values: (T | Promise)[]): Promise; /** * Creates a new rejected promise for the provided reason. @@ -4839,15 +4807,13 @@ interface PromiseConstructor { * @param value A promise. * @returns A promise whose internal state matches the provided promise. */ - resolve(value: T | PromiseLike): Promise; + resolve(value: T | Promise): Promise; /** * Creates a new resolved promise . * @returns A resolved promise. */ resolve(): Promise; - - [Symbol.species]: Function; } declare var Promise: PromiseConstructor; @@ -8734,8 +8700,6 @@ interface HTMLCanvasElement extends HTMLElement { * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas. * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl"); */ - getContext(contextId: "2d"): CanvasRenderingContext2D; - getContext(contextId: "experimental-webgl"): WebGLRenderingContext; getContext(contextId: string, ...args: any[]): CanvasRenderingContext2D | WebGLRenderingContext; /** * Returns a blob object encoded as a Portable Network Graphics (PNG) format from a canvas image or drawing. @@ -17217,7 +17181,6 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget { overrideMimeType(mime: string): void; send(data?: Document): void; send(data?: string): void; - send(data?: any): void; setRequestHeader(header: string, value: string): void; DONE: number; HEADERS_RECEIVED: number; @@ -17372,13 +17335,11 @@ interface DocumentEvent { createEvent(eventInterface:"CloseEvent"): CloseEvent; createEvent(eventInterface:"CommandEvent"): CommandEvent; createEvent(eventInterface:"CompositionEvent"): CompositionEvent; - createEvent(eventInterface: "CustomEvent"): CustomEvent; createEvent(eventInterface:"DeviceMotionEvent"): DeviceMotionEvent; createEvent(eventInterface:"DeviceOrientationEvent"): DeviceOrientationEvent; createEvent(eventInterface:"DragEvent"): DragEvent; createEvent(eventInterface:"ErrorEvent"): ErrorEvent; createEvent(eventInterface:"Event"): Event; - createEvent(eventInterface:"Events"): Event; createEvent(eventInterface:"FocusEvent"): FocusEvent; createEvent(eventInterface:"GamepadEvent"): GamepadEvent; createEvent(eventInterface:"HashChangeEvent"): HashChangeEvent; @@ -17393,12 +17354,8 @@ interface DocumentEvent { createEvent(eventInterface:"MSSiteModeEvent"): MSSiteModeEvent; createEvent(eventInterface:"MessageEvent"): MessageEvent; createEvent(eventInterface:"MouseEvent"): MouseEvent; - createEvent(eventInterface:"MouseEvents"): MouseEvent; createEvent(eventInterface:"MouseWheelEvent"): MouseWheelEvent; - createEvent(eventInterface:"MSGestureEvent"): MSGestureEvent; - createEvent(eventInterface:"MSPointerEvent"): MSPointerEvent; createEvent(eventInterface:"MutationEvent"): MutationEvent; - createEvent(eventInterface:"MutationEvents"): MutationEvent; createEvent(eventInterface:"NavigationCompletedEvent"): NavigationCompletedEvent; createEvent(eventInterface:"NavigationEvent"): NavigationEvent; createEvent(eventInterface:"NavigationEventWithReferrer"): NavigationEventWithReferrer; @@ -17409,7 +17366,6 @@ interface DocumentEvent { createEvent(eventInterface:"PopStateEvent"): PopStateEvent; createEvent(eventInterface:"ProgressEvent"): ProgressEvent; createEvent(eventInterface:"SVGZoomEvent"): SVGZoomEvent; - createEvent(eventInterface:"SVGZoomEvents"): SVGZoomEvent; createEvent(eventInterface:"ScriptNotifyEvent"): ScriptNotifyEvent; createEvent(eventInterface:"StorageEvent"): StorageEvent; createEvent(eventInterface:"TextEvent"): TextEvent; @@ -17417,7 +17373,6 @@ interface DocumentEvent { createEvent(eventInterface:"TrackEvent"): TrackEvent; createEvent(eventInterface:"TransitionEvent"): TransitionEvent; createEvent(eventInterface:"UIEvent"): UIEvent; - createEvent(eventInterface:"UIEvents"): UIEvent; createEvent(eventInterface:"UnviewableContentIdentifiedEvent"): UnviewableContentIdentifiedEvent; createEvent(eventInterface:"WebGLContextEvent"): WebGLContextEvent; createEvent(eventInterface:"WheelEvent"): WheelEvent; From c8d56bb1c57d56fcc5c4a0c44ff6c6491cc7367f Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Wed, 6 May 2015 11:33:48 -0700 Subject: [PATCH 3/3] Update tsserver.js --- tsserver/tsserver.js | 142 ++++++++++++++++++++++++------------------- 1 file changed, 81 insertions(+), 61 deletions(-) diff --git a/tsserver/tsserver.js b/tsserver/tsserver.js index e492912a..7538e430 100644 --- a/tsserver/tsserver.js +++ b/tsserver/tsserver.js @@ -1277,6 +1277,8 @@ var ts; An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: ts.DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." }, A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: ts.DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." }, A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: ts.DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." }, + _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 2502, category: ts.DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own type annotation." }, + Cannot_find_namespace_0: { code: 2503, category: ts.DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: ts.DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -1431,7 +1433,6 @@ var ts; Object_literal_s_property_0_implicitly_has_an_1_type: { code: 7018, category: ts.DiagnosticCategory.Error, key: "Object literal's property '{0}' implicitly has an '{1}' type." }, Rest_parameter_0_implicitly_has_an_any_type: { code: 7019, category: ts.DiagnosticCategory.Error, key: "Rest parameter '{0}' implicitly has an 'any[]' type." }, Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7020, category: ts.DiagnosticCategory.Error, key: "Call signature, which lacks return-type annotation, implicitly has an 'any' return type." }, - _0_implicitly_has_type_any_because_it_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 7021, category: ts.DiagnosticCategory.Error, key: "'{0}' implicitly has type 'any' because it is referenced directly or indirectly in its own type annotation." }, _0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: { code: 7022, category: ts.DiagnosticCategory.Error, key: "'{0}' implicitly has type 'any' because it is does not have a type annotation and is referenced directly or indirectly in its own initializer." }, _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7023, category: ts.DiagnosticCategory.Error, key: "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." }, Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: ts.DiagnosticCategory.Error, key: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." }, @@ -8967,7 +8968,6 @@ var ts; var undefinedType = createIntrinsicType(32 | 262144, "undefined"); var nullType = createIntrinsicType(64 | 262144, "null"); var unknownType = createIntrinsicType(1, "unknown"); - var resolvingType = createIntrinsicType(1, "__resolving__"); var emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); @@ -8997,6 +8997,8 @@ var ts; var emitExtends = false; var emitDecorate = false; var emitParam = false; + var resolutionTargets = []; + var resolutionResults = []; var mergedSymbols = []; var symbolLinks = []; var nodeLinks = []; @@ -9216,9 +9218,9 @@ var ts; } else if (location.kind === 228 || (location.kind === 206 && location.name.kind === 8)) { - result = getSymbol(getSymbolOfNode(location).exports, "default", meaning & 8914931); + result = getSymbolOfNode(location).exports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); - if (result && (result.flags & meaning) && localSymbol && localSymbol.name === name) { + if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; @@ -9547,7 +9549,8 @@ var ts; } var symbol; if (name.kind === 65) { - symbol = resolveName(name, name.text, meaning, ts.Diagnostics.Cannot_find_name_0, name); + var message = meaning === 1536 ? ts.Diagnostics.Cannot_find_namespace_0 : ts.Diagnostics.Cannot_find_name_0; + symbol = resolveName(name, name.text, meaning, message, name); if (!symbol) { return undefined; } @@ -10518,6 +10521,26 @@ var ts; }); } } + function pushTypeResolution(target) { + var i = 0; + var count = resolutionTargets.length; + while (i < count && resolutionTargets[i] !== target) { + i++; + } + if (i < count) { + do { + resolutionResults[i++] = false; + } while (i < count); + return false; + } + resolutionTargets.push(target); + resolutionResults.push(true); + return true; + } + function popTypeResolution() { + resolutionTargets.pop(); + return resolutionResults.pop(); + } function getRootDeclaration(node) { while (node.kind === 153) { node = node.parent.parent; @@ -10695,20 +10718,23 @@ var ts; if (declaration.kind === 215) { return links.type = checkExpression(declaration.expression); } - links.type = resolvingType; - var type = getWidenedTypeForVariableLikeDeclaration(declaration, true); - if (links.type === resolvingType) { - links.type = type; + if (!pushTypeResolution(symbol)) { + return unknownType; } - } - else if (links.type === resolvingType) { - links.type = anyType; - if (compilerOptions.noImplicitAny) { - var diagnostic = symbol.valueDeclaration.type ? - ts.Diagnostics._0_implicitly_has_type_any_because_it_is_referenced_directly_or_indirectly_in_its_own_type_annotation : - ts.Diagnostics._0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer; - error(symbol.valueDeclaration, diagnostic, symbolToString(symbol)); + var type = getWidenedTypeForVariableLikeDeclaration(declaration, true); + if (!popTypeResolution()) { + if (symbol.valueDeclaration.type) { + type = unknownType; + error(symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + } + else { + type = anyType; + if (compilerOptions.noImplicitAny) { + error(symbol.valueDeclaration, ts.Diagnostics._0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol)); + } + } } + links.type = type; } return links.type; } @@ -10729,13 +10755,10 @@ var ts; } function getTypeOfAccessors(symbol) { var links = getSymbolLinks(symbol); - checkAndStoreTypeOfAccessors(symbol, links); - return links.type; - } - function checkAndStoreTypeOfAccessors(symbol, links) { - links = links || getSymbolLinks(symbol); if (!links.type) { - links.type = resolvingType; + if (!pushTypeResolution(symbol)) { + return unknownType; + } var getter = ts.getDeclarationOfKind(symbol, 137); var setter = ts.getDeclarationOfKind(symbol, 138); var type; @@ -10760,17 +10783,16 @@ var ts; } } } - if (links.type === resolvingType) { - links.type = type; - } - } - else if (links.type === resolvingType) { - links.type = anyType; - if (compilerOptions.noImplicitAny) { - var getter = ts.getDeclarationOfKind(symbol, 137); - error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); + if (!popTypeResolution()) { + type = anyType; + if (compilerOptions.noImplicitAny) { + var getter_1 = ts.getDeclarationOfKind(symbol, 137); + error(getter_1, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); + } } + links.type = type; } + return links.type; } function getTypeOfFuncClassEnumModule(symbol) { var links = getSymbolLinks(symbol); @@ -10932,17 +10954,16 @@ var ts; function getDeclaredTypeOfTypeAlias(symbol) { var links = getSymbolLinks(symbol); if (!links.declaredType) { - links.declaredType = resolvingType; + if (!pushTypeResolution(links)) { + return unknownType; + } var declaration = ts.getDeclarationOfKind(symbol, 204); var type = getTypeFromTypeNode(declaration.type); - if (links.declaredType === resolvingType) { - links.declaredType = type; + if (!popTypeResolution()) { + type = unknownType; + error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } - } - else if (links.declaredType === resolvingType) { - links.declaredType = unknownType; - var declaration = ts.getDeclarationOfKind(symbol, 204); - error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); + links.declaredType = type; } return links.declaredType; } @@ -11481,7 +11502,9 @@ var ts; } function getReturnTypeOfSignature(signature) { if (!signature.resolvedReturnType) { - signature.resolvedReturnType = resolvingType; + if (!pushTypeResolution(signature)) { + return unknownType; + } var type; if (signature.target) { type = instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper); @@ -11492,21 +11515,19 @@ var ts; else { type = getReturnTypeFromBody(signature.declaration); } - if (signature.resolvedReturnType === resolvingType) { - signature.resolvedReturnType = type; - } - } - else if (signature.resolvedReturnType === resolvingType) { - signature.resolvedReturnType = anyType; - if (compilerOptions.noImplicitAny) { - var declaration = signature.declaration; - if (declaration.name) { - error(declaration.name, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, ts.declarationNameToString(declaration.name)); - } - else { - error(declaration, ts.Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions); + if (!popTypeResolution()) { + type = anyType; + if (compilerOptions.noImplicitAny) { + var declaration = signature.declaration; + if (declaration.name) { + error(declaration.name, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, ts.declarationNameToString(declaration.name)); + } + else { + error(declaration, ts.Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions); + } } } + signature.resolvedReturnType = type; } return signature.resolvedReturnType; } @@ -14756,10 +14777,9 @@ var ts; if (isContextSensitive(node)) { assignContextualParameterTypes(signature, contextualSignature, contextualMapper || identityMapper); } - if (!node.type) { - signature.resolvedReturnType = resolvingType; + if (!node.type && !signature.resolvedReturnType) { var returnType = getReturnTypeFromBody(node, contextualMapper); - if (signature.resolvedReturnType === resolvingType) { + if (!signature.resolvedReturnType) { signature.resolvedReturnType = returnType; } } @@ -15540,7 +15560,7 @@ var ts; } } } - checkAndStoreTypeOfAccessors(getSymbolOfNode(node)); + getTypeOfAccessors(getSymbolOfNode(node)); } checkFunctionLikeDeclaration(node); } @@ -36854,11 +36874,11 @@ var ts; configFilename = ts.normalizePath(configFilename); var dirPath = ts.getDirectoryPath(configFilename); var rawConfig = ts.readConfigFile(configFilename); - if (!rawConfig) { - return { errorMsg: "tsconfig syntax error" }; + if (rawConfig.error) { + return rawConfig.error; } else { - var parsedCommandLine = ts.parseConfigFile(rawConfig, ts.sys, dirPath); + var parsedCommandLine = ts.parseConfigFile(rawConfig.config, ts.sys, dirPath); if (parsedCommandLine.errors && (parsedCommandLine.errors.length > 0)) { return { errorMsg: "tsconfig option errors" }; }