From 756efd2478dd4fcb492f53f335a0e4afcd7c875d Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 15 Nov 2023 18:01:59 -0800 Subject: [PATCH] Fixes for release-5.3. (#56424) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Mateusz Burzyński Co-authored-by: Sheetal Nandi Co-authored-by: Jake Bailey <5341706+jakebailey@users.noreply.github.com> --- package.json | 2 +- src/compiler/checker.ts | 23 +- src/compiler/corePublic.ts | 2 +- src/compiler/factory/nodeFactory.ts | 5 +- src/compiler/transformers/declarations.ts | 9 +- src/compiler/transformers/generators.ts | 2 +- src/compiler/transformers/ts.ts | 4 +- src/compiler/utilitiesPublic.ts | 7 +- ...eturnTypeErrorInReturnStatement.errors.txt | 16 + ...nferredReturnTypeErrorInReturnStatement.js | 27 + ...edReturnTypeErrorInReturnStatement.symbols | 19 + ...rredReturnTypeErrorInReturnStatement.types | 26 + .../reference/binaryIntegerLiteral.types | 2 +- .../reference/binaryIntegerLiteralES6.types | 2 +- .../reference/fakeInfinity1.errors.txt | 29 + tests/baselines/reference/fakeInfinity1.js | 46 + .../baselines/reference/fakeInfinity1.symbols | 56 ++ tests/baselines/reference/fakeInfinity1.types | 64 ++ tests/baselines/reference/fakeInfinity2.js | 62 ++ .../baselines/reference/fakeInfinity2.symbols | 37 + tests/baselines/reference/fakeInfinity2.types | 41 + tests/baselines/reference/fakeInfinity3.js | 70 ++ .../baselines/reference/fakeInfinity3.symbols | 40 + tests/baselines/reference/fakeInfinity3.types | 45 + .../reference/octalIntegerLiteral.types | 2 +- .../reference/octalIntegerLiteralES6.types | 2 +- .../reference/trackedSymbolsNoCrash.js | 946 ++++++++++++++++++ .../reference/trackedSymbolsNoCrash.symbols | 944 +++++++++++++++++ .../reference/trackedSymbolsNoCrash.types | 640 ++++++++++++ ...nferredReturnTypeErrorInReturnStatement.ts | 9 + tests/cases/compiler/fakeInfinity1.ts | 25 + tests/cases/compiler/fakeInfinity2.ts | 18 + tests/cases/compiler/fakeInfinity3.ts | 20 + tests/cases/compiler/trackedSymbolsNoCrash.ts | 119 +++ .../jsDocFunctionTypeCompletionsNoCrash.ts | 13 + 35 files changed, 3337 insertions(+), 37 deletions(-) create mode 100644 tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.errors.txt create mode 100644 tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.js create mode 100644 tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.symbols create mode 100644 tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.types create mode 100644 tests/baselines/reference/fakeInfinity1.errors.txt create mode 100644 tests/baselines/reference/fakeInfinity1.js create mode 100644 tests/baselines/reference/fakeInfinity1.symbols create mode 100644 tests/baselines/reference/fakeInfinity1.types create mode 100644 tests/baselines/reference/fakeInfinity2.js create mode 100644 tests/baselines/reference/fakeInfinity2.symbols create mode 100644 tests/baselines/reference/fakeInfinity2.types create mode 100644 tests/baselines/reference/fakeInfinity3.js create mode 100644 tests/baselines/reference/fakeInfinity3.symbols create mode 100644 tests/baselines/reference/fakeInfinity3.types create mode 100644 tests/baselines/reference/trackedSymbolsNoCrash.js create mode 100644 tests/baselines/reference/trackedSymbolsNoCrash.symbols create mode 100644 tests/baselines/reference/trackedSymbolsNoCrash.types create mode 100644 tests/cases/compiler/accessorInferredReturnTypeErrorInReturnStatement.ts create mode 100644 tests/cases/compiler/fakeInfinity1.ts create mode 100644 tests/cases/compiler/fakeInfinity2.ts create mode 100644 tests/cases/compiler/fakeInfinity3.ts create mode 100644 tests/cases/compiler/trackedSymbolsNoCrash.ts create mode 100644 tests/cases/fourslash/jsDocFunctionTypeCompletionsNoCrash.ts diff --git a/package.json b/package.json index 1fb5805c4287f..ee3d25aa945d2 100644 --- a/package.json +++ b/package.json @@ -2,7 +2,7 @@ "name": "typescript", "author": "Microsoft Corp.", "homepage": "https://www.typescriptlang.org/", - "version": "5.3.1-rc", + "version": "5.3.2", "license": "Apache-2.0", "description": "TypeScript is a language for application scale JavaScript development", "keywords": [ diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3ac1038a4cdbe..560783a71b58d 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1868,7 +1868,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const nodeLinks = getNodeLinks(node); cachedResolvedSignatures.push([nodeLinks, nodeLinks.resolvedSignature] as const); nodeLinks.resolvedSignature = undefined; - if (isFunctionLike(node)) { + if (isFunctionExpressionOrArrowFunction(node)) { const symbolLinks = getSymbolLinks(getSymbolOfDeclaration(node)); const type = symbolLinks.type; cachedTypes.push([symbolLinks, type] as const); @@ -6949,6 +6949,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { context.symbolDepth!.set(id, depth + 1); } context.visitedTypes.add(typeId); + const prevTrackedSymbols = context.trackedSymbols; + context.trackedSymbols = undefined; const startLength = context.approximateLength; const result = transform(type); const addedLength = context.approximateLength - startLength; @@ -6964,6 +6966,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (id) { context.symbolDepth!.set(id, depth!); } + context.trackedSymbols = prevTrackedSymbols; return result; function deepCloneOrReuseNode(node: T): T { @@ -7312,7 +7315,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (propertySymbol.flags & SymbolFlags.Accessor) { const writeType = getWriteTypeOfSymbol(propertySymbol); - if (propertyType !== writeType) { + if (propertyType !== writeType && !isErrorType(propertyType) && !isErrorType(writeType)) { const getterDeclaration = getDeclarationOfKind(propertySymbol, SyntaxKind.GetAccessor)!; const getterSignature = getSignatureFromDeclaration(getterDeclaration); typeElements.push( @@ -8299,7 +8302,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return factory.createStringLiteral(name, !!singleQuote); } if (isNumericLiteralName(name) && startsWith(name, "-")) { - return factory.createComputedPropertyName(factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(+name)))); + return factory.createComputedPropertyName(factory.createNumericLiteral(+name)); } return createPropertyNameNodeForIdentifierOrLiteral(name, getEmitScriptTarget(compilerOptions), singleQuote, stringNamed, isMethod); } @@ -38953,14 +38956,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return hasSkipDirectInferenceFlag(node) ? blockedStringType : getFreshTypeOfLiteralType(getStringLiteralType((node as StringLiteralLike).text)); - case SyntaxKind.NumericLiteral: { + case SyntaxKind.NumericLiteral: checkGrammarNumericLiteral(node as NumericLiteral); - const value = +(node as NumericLiteral).text; - if (!isFinite(value)) { - return numberType; - } - return getFreshTypeOfLiteralType(getNumberLiteralType(value)); - } + return getFreshTypeOfLiteralType(getNumberLiteralType(+(node as NumericLiteral).text)); case SyntaxKind.BigIntLiteral: checkGrammarBigIntLiteral(node as BigIntLiteral); return getFreshTypeOfLiteralType(getBigIntLiteralType({ @@ -47883,9 +47881,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (enumResult) return enumResult; const literalValue = (type as LiteralType).value; return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : - typeof literalValue === "string" ? factory.createStringLiteral(literalValue) : - literalValue < 0 ? factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(literalValue))) : - factory.createNumericLiteral(literalValue); + typeof literalValue === "number" ? factory.createNumericLiteral(literalValue) : + factory.createStringLiteral(literalValue); } function createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker) { diff --git a/src/compiler/corePublic.ts b/src/compiler/corePublic.ts index cbeddf4855eb2..5f4184600cb19 100644 --- a/src/compiler/corePublic.ts +++ b/src/compiler/corePublic.ts @@ -4,7 +4,7 @@ export const versionMajorMinor = "5.3"; // The following is baselined as a literal template type without intervention /** The version of the TypeScript compiler release */ // eslint-disable-next-line @typescript-eslint/no-inferrable-types -export const version = "5.3.1-rc" as string; +export const version = "5.3.2" as string; /** * Type of objects whose values are all of the same type. diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index 6964705e9432e..ff6054412349d 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -44,7 +44,6 @@ import { CaseOrDefaultClause, cast, CatchClause, - CharacterCodes, ClassDeclaration, ClassElement, ClassExpression, @@ -1254,10 +1253,8 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode // @api function createNumericLiteral(value: string | number, numericLiteralFlags: TokenFlags = TokenFlags.None): NumericLiteral { - const text = typeof value === "number" ? value + "" : value; - Debug.assert(text.charCodeAt(0) !== CharacterCodes.minus, "Negative numbers should be created in combination with createPrefixUnaryExpression"); const node = createBaseDeclaration(SyntaxKind.NumericLiteral); - node.text = text; + node.text = typeof value === "number" ? value + "" : value; node.numericLiteralFlags = numericLiteralFlags; if (numericLiteralFlags & TokenFlags.BinaryOrOctalSpecifier) node.transformFlags |= TransformFlags.ContainsES2015; return node; diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index e649e1b2b4330..717990084716c 100644 --- a/src/compiler/transformers/declarations.ts +++ b/src/compiler/transformers/declarations.ts @@ -1798,14 +1798,7 @@ export function transformDeclarations(context: TransformationContext) { if (shouldStripInternal(m)) return; // Rewrite enum values to their constants, if available const constValue = resolver.getConstantValue(m); - const newInitializer = constValue === undefined - ? undefined - : typeof constValue === "string" - ? factory.createStringLiteral(constValue) - : constValue < 0 - ? factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(constValue))) - : factory.createNumericLiteral(constValue); - return preserveJsDoc(factory.updateEnumMember(m, m.name, newInitializer), m); + return preserveJsDoc(factory.updateEnumMember(m, m.name, constValue !== undefined ? typeof constValue === "string" ? factory.createStringLiteral(constValue) : factory.createNumericLiteral(constValue) : undefined), m); })), )); } diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index 775075a6e8f6f..39f9a967e0cb3 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -2524,7 +2524,7 @@ export function transformGenerators(context: TransformationContext): (x: SourceF labelExpressions = []; } - const expression = factory.createNumericLiteral(Number.MAX_SAFE_INTEGER); + const expression = factory.createNumericLiteral(-1); if (labelExpressions[label] === undefined) { labelExpressions[label] = [expression]; } diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 584cf837e180a..ac5855d72c8de 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1901,9 +1901,7 @@ export function transformTypeScript(context: TransformationContext) { function transformEnumMemberDeclarationValue(member: EnumMember): Expression { const value = resolver.getConstantValue(member); if (value !== undefined) { - return typeof value === "string" ? factory.createStringLiteral(value) : - value < 0 ? factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))) : - factory.createNumericLiteral(value); + return typeof value === "string" ? factory.createStringLiteral(value) : factory.createNumericLiteral(value); } else { enableSubstitutionForNonQualifiedEnumMembers(); diff --git a/src/compiler/utilitiesPublic.ts b/src/compiler/utilitiesPublic.ts index 98830e1a73961..688ef16272039 100644 --- a/src/compiler/utilitiesPublic.ts +++ b/src/compiler/utilitiesPublic.ts @@ -5,6 +5,7 @@ import { ArrayBindingElement, ArrayBindingOrAssignmentElement, ArrayBindingOrAssignmentPattern, + ArrowFunction, AssertionExpression, AssignmentDeclarationKind, AssignmentPattern, @@ -64,6 +65,7 @@ import { ForInitializer, ForInOrOfStatement, FunctionBody, + FunctionExpression, FunctionLikeDeclaration, FunctionTypeNode, GeneratedIdentifier, @@ -119,6 +121,7 @@ import { isExportSpecifier, isFunctionBlock, isFunctionExpression, + isFunctionExpressionOrArrowFunction, isFunctionTypeNode, isIdentifier, isImportSpecifier, @@ -1928,8 +1931,8 @@ export function isPropertyAccessOrQualifiedName(node: Node): node is PropertyAcc } /** @internal */ -export function isCallLikeOrFunctionLikeExpression(node: Node): node is CallLikeExpression | SignatureDeclaration { - return isCallLikeExpression(node) || isFunctionLike(node); +export function isCallLikeOrFunctionLikeExpression(node: Node): node is CallLikeExpression | FunctionExpression | ArrowFunction { + return isCallLikeExpression(node) || isFunctionExpressionOrArrowFunction(node); } export function isCallLikeExpression(node: Node): node is CallLikeExpression { diff --git a/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.errors.txt b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.errors.txt new file mode 100644 index 0000000000000..1f3c97970e28b --- /dev/null +++ b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.errors.txt @@ -0,0 +1,16 @@ +accessorInferredReturnTypeErrorInReturnStatement.ts(2,7): error TS7023: 'primaryPath' 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. +accessorInferredReturnTypeErrorInReturnStatement.ts(4,18): error TS2339: Property 'collection' does not exist on type '{ readonly primaryPath: any; }'. + + +==== accessorInferredReturnTypeErrorInReturnStatement.ts (2 errors) ==== + export var basePrototype = { + get primaryPath() { + ~~~~~~~~~~~ +!!! error TS7023: 'primaryPath' 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. + var _this = this; + return _this.collection.schema.primaryPath; + ~~~~~~~~~~ +!!! error TS2339: Property 'collection' does not exist on type '{ readonly primaryPath: any; }'. + }, + }; + \ No newline at end of file diff --git a/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.js b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.js new file mode 100644 index 0000000000000..0d1bd77500ce7 --- /dev/null +++ b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.js @@ -0,0 +1,27 @@ +//// [tests/cases/compiler/accessorInferredReturnTypeErrorInReturnStatement.ts] //// + +//// [accessorInferredReturnTypeErrorInReturnStatement.ts] +export var basePrototype = { + get primaryPath() { + var _this = this; + return _this.collection.schema.primaryPath; + }, +}; + + +//// [accessorInferredReturnTypeErrorInReturnStatement.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.basePrototype = void 0; +exports.basePrototype = { + get primaryPath() { + var _this = this; + return _this.collection.schema.primaryPath; + }, +}; + + +//// [accessorInferredReturnTypeErrorInReturnStatement.d.ts] +export declare var basePrototype: { + readonly primaryPath: any; +}; diff --git a/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.symbols b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.symbols new file mode 100644 index 0000000000000..a2525fe0e7237 --- /dev/null +++ b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.symbols @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/accessorInferredReturnTypeErrorInReturnStatement.ts] //// + +=== accessorInferredReturnTypeErrorInReturnStatement.ts === +export var basePrototype = { +>basePrototype : Symbol(basePrototype, Decl(accessorInferredReturnTypeErrorInReturnStatement.ts, 0, 10)) + + get primaryPath() { +>primaryPath : Symbol(primaryPath, Decl(accessorInferredReturnTypeErrorInReturnStatement.ts, 0, 28)) + + var _this = this; +>_this : Symbol(_this, Decl(accessorInferredReturnTypeErrorInReturnStatement.ts, 2, 7)) +>this : Symbol(basePrototype, Decl(accessorInferredReturnTypeErrorInReturnStatement.ts, 0, 26)) + + return _this.collection.schema.primaryPath; +>_this : Symbol(_this, Decl(accessorInferredReturnTypeErrorInReturnStatement.ts, 2, 7)) + + }, +}; + diff --git a/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.types b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.types new file mode 100644 index 0000000000000..5c48b09abd26d --- /dev/null +++ b/tests/baselines/reference/accessorInferredReturnTypeErrorInReturnStatement.types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/accessorInferredReturnTypeErrorInReturnStatement.ts] //// + +=== accessorInferredReturnTypeErrorInReturnStatement.ts === +export var basePrototype = { +>basePrototype : { readonly primaryPath: any; } +>{ get primaryPath() { var _this = this; return _this.collection.schema.primaryPath; }, } : { readonly primaryPath: any; } + + get primaryPath() { +>primaryPath : any + + var _this = this; +>_this : { readonly primaryPath: any; } +>this : { readonly primaryPath: any; } + + return _this.collection.schema.primaryPath; +>_this.collection.schema.primaryPath : any +>_this.collection.schema : any +>_this.collection : any +>_this : { readonly primaryPath: any; } +>collection : any +>schema : any +>primaryPath : any + + }, +}; + diff --git a/tests/baselines/reference/binaryIntegerLiteral.types b/tests/baselines/reference/binaryIntegerLiteral.types index 48b9d9532cc1a..2c81595c0c8b4 100644 --- a/tests/baselines/reference/binaryIntegerLiteral.types +++ b/tests/baselines/reference/binaryIntegerLiteral.types @@ -15,7 +15,7 @@ var bin3 = 0B1111111111111111111111111111111111111111111111110100101010000001011 var bin4 = 0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111; >bin4 : number ->0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111 : number +>0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111 : Infinity var obj1 = { >obj1 : { 26: string; a: number; bin1: number; b: number; Infinity: boolean; } diff --git a/tests/baselines/reference/binaryIntegerLiteralES6.types b/tests/baselines/reference/binaryIntegerLiteralES6.types index 8b6d7437affd4..2abc7ca72ca22 100644 --- a/tests/baselines/reference/binaryIntegerLiteralES6.types +++ b/tests/baselines/reference/binaryIntegerLiteralES6.types @@ -15,7 +15,7 @@ var bin3 = 0B1111111111111111111111111111111111111111111111110100101010000001011 var bin4 = 0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111; >bin4 : number ->0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111 : number +>0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111 : Infinity var obj1 = { >obj1 : { 26: string; a: number; bin1: number; b: number; Infinity: boolean; } diff --git a/tests/baselines/reference/fakeInfinity1.errors.txt b/tests/baselines/reference/fakeInfinity1.errors.txt new file mode 100644 index 0000000000000..52fd2751609ed --- /dev/null +++ b/tests/baselines/reference/fakeInfinity1.errors.txt @@ -0,0 +1,29 @@ +fakeInfinity1.ts(17,1): error TS2322: Type 'number' is not assignable to type 'Infinity'. + + +==== fakeInfinity1.ts (1 errors) ==== + // These are not actually the real infinity. + export type PositiveInfinity = 1e999; + export type NegativeInfinity = -1e999; + + export type TypeOfInfinity = typeof Infinity; + export type TypeOfNaN = typeof NaN; + + type A = 1e999; + type B = 1e9999; + + declare let a: A; + declare let b: B; + + a = b; + b = a; + + a = Infinity; + ~ +!!! error TS2322: Type 'number' is not assignable to type 'Infinity'. + a = 1e999; + a = 1e9999; + + export type Oops = 123456789123456789123456789123456789123456789123456789; + export const oops = 123456789123456789123456789123456789123456789123456789; + \ No newline at end of file diff --git a/tests/baselines/reference/fakeInfinity1.js b/tests/baselines/reference/fakeInfinity1.js new file mode 100644 index 0000000000000..c28497a9fa3a0 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity1.js @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/fakeInfinity1.ts] //// + +//// [fakeInfinity1.ts] +// These are not actually the real infinity. +export type PositiveInfinity = 1e999; +export type NegativeInfinity = -1e999; + +export type TypeOfInfinity = typeof Infinity; +export type TypeOfNaN = typeof NaN; + +type A = 1e999; +type B = 1e9999; + +declare let a: A; +declare let b: B; + +a = b; +b = a; + +a = Infinity; +a = 1e999; +a = 1e9999; + +export type Oops = 123456789123456789123456789123456789123456789123456789; +export const oops = 123456789123456789123456789123456789123456789123456789; + + +//// [fakeInfinity1.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.oops = void 0; +a = b; +b = a; +a = Infinity; +a = 1e999; +a = 1e9999; +exports.oops = 123456789123456789123456789123456789123456789123456789; + + +//// [fakeInfinity1.d.ts] +export type PositiveInfinity = 1e999; +export type NegativeInfinity = -1e999; +export type TypeOfInfinity = typeof Infinity; +export type TypeOfNaN = typeof NaN; +export type Oops = 123456789123456789123456789123456789123456789123456789; +export declare const oops = 1.2345678912345678e+53; diff --git a/tests/baselines/reference/fakeInfinity1.symbols b/tests/baselines/reference/fakeInfinity1.symbols new file mode 100644 index 0000000000000..07cb183dae865 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity1.symbols @@ -0,0 +1,56 @@ +//// [tests/cases/compiler/fakeInfinity1.ts] //// + +=== fakeInfinity1.ts === +// These are not actually the real infinity. +export type PositiveInfinity = 1e999; +>PositiveInfinity : Symbol(PositiveInfinity, Decl(fakeInfinity1.ts, 0, 0)) + +export type NegativeInfinity = -1e999; +>NegativeInfinity : Symbol(NegativeInfinity, Decl(fakeInfinity1.ts, 1, 37)) + +export type TypeOfInfinity = typeof Infinity; +>TypeOfInfinity : Symbol(TypeOfInfinity, Decl(fakeInfinity1.ts, 2, 38)) +>Infinity : Symbol(Infinity, Decl(lib.es5.d.ts, --, --)) + +export type TypeOfNaN = typeof NaN; +>TypeOfNaN : Symbol(TypeOfNaN, Decl(fakeInfinity1.ts, 4, 45)) +>NaN : Symbol(NaN, Decl(lib.es5.d.ts, --, --)) + +type A = 1e999; +>A : Symbol(A, Decl(fakeInfinity1.ts, 5, 35)) + +type B = 1e9999; +>B : Symbol(B, Decl(fakeInfinity1.ts, 7, 15)) + +declare let a: A; +>a : Symbol(a, Decl(fakeInfinity1.ts, 10, 11)) +>A : Symbol(A, Decl(fakeInfinity1.ts, 5, 35)) + +declare let b: B; +>b : Symbol(b, Decl(fakeInfinity1.ts, 11, 11)) +>B : Symbol(B, Decl(fakeInfinity1.ts, 7, 15)) + +a = b; +>a : Symbol(a, Decl(fakeInfinity1.ts, 10, 11)) +>b : Symbol(b, Decl(fakeInfinity1.ts, 11, 11)) + +b = a; +>b : Symbol(b, Decl(fakeInfinity1.ts, 11, 11)) +>a : Symbol(a, Decl(fakeInfinity1.ts, 10, 11)) + +a = Infinity; +>a : Symbol(a, Decl(fakeInfinity1.ts, 10, 11)) +>Infinity : Symbol(Infinity, Decl(lib.es5.d.ts, --, --)) + +a = 1e999; +>a : Symbol(a, Decl(fakeInfinity1.ts, 10, 11)) + +a = 1e9999; +>a : Symbol(a, Decl(fakeInfinity1.ts, 10, 11)) + +export type Oops = 123456789123456789123456789123456789123456789123456789; +>Oops : Symbol(Oops, Decl(fakeInfinity1.ts, 18, 11)) + +export const oops = 123456789123456789123456789123456789123456789123456789; +>oops : Symbol(oops, Decl(fakeInfinity1.ts, 21, 12)) + diff --git a/tests/baselines/reference/fakeInfinity1.types b/tests/baselines/reference/fakeInfinity1.types new file mode 100644 index 0000000000000..0d5f3d1aa4f37 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity1.types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/fakeInfinity1.ts] //// + +=== fakeInfinity1.ts === +// These are not actually the real infinity. +export type PositiveInfinity = 1e999; +>PositiveInfinity : Infinity + +export type NegativeInfinity = -1e999; +>NegativeInfinity : -Infinity +>-1e999 : -Infinity +>1e999 : Infinity + +export type TypeOfInfinity = typeof Infinity; +>TypeOfInfinity : number +>Infinity : number + +export type TypeOfNaN = typeof NaN; +>TypeOfNaN : number +>NaN : number + +type A = 1e999; +>A : Infinity + +type B = 1e9999; +>B : Infinity + +declare let a: A; +>a : Infinity + +declare let b: B; +>b : Infinity + +a = b; +>a = b : Infinity +>a : Infinity +>b : Infinity + +b = a; +>b = a : Infinity +>b : Infinity +>a : Infinity + +a = Infinity; +>a = Infinity : number +>a : Infinity +>Infinity : number + +a = 1e999; +>a = 1e999 : Infinity +>a : Infinity +>1e999 : Infinity + +a = 1e9999; +>a = 1e9999 : Infinity +>a : Infinity +>1e9999 : Infinity + +export type Oops = 123456789123456789123456789123456789123456789123456789; +>Oops : 1.2345678912345678e+53 + +export const oops = 123456789123456789123456789123456789123456789123456789; +>oops : 1.2345678912345678e+53 +>123456789123456789123456789123456789123456789123456789 : 1.2345678912345678e+53 + diff --git a/tests/baselines/reference/fakeInfinity2.js b/tests/baselines/reference/fakeInfinity2.js new file mode 100644 index 0000000000000..779b0f421d988 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity2.js @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/fakeInfinity2.ts] //// + +//// [fakeInfinity2.ts] +export enum Foo { + A = 1e999, + B = -1e999, +} + +namespace X { + type A = 1e999; + type B = 2e999; + + export function f(): A { + throw new Error() + } +} + +export const m = X.f(); + + +//// [fakeInfinity2.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.m = exports.Foo = void 0; +var Foo; +(function (Foo) { + Foo[Foo["A"] = Infinity] = "A"; + Foo[Foo["B"] = -Infinity] = "B"; +})(Foo || (exports.Foo = Foo = {})); +var X; +(function (X) { + function f() { + throw new Error(); + } + X.f = f; +})(X || (X = {})); +exports.m = X.f(); + + +//// [fakeInfinity2.d.ts] +export declare enum Foo { + A = Infinity, + B = -Infinity +} +export declare const m: Infinity; + + +//// [DtsFileErrors] + + +fakeInfinity2.d.ts(5,25): error TS2749: 'Infinity' refers to a value, but is being used as a type here. Did you mean 'typeof Infinity'? + + +==== fakeInfinity2.d.ts (1 errors) ==== + export declare enum Foo { + A = Infinity, + B = -Infinity + } + export declare const m: Infinity; + ~~~~~~~~ +!!! error TS2749: 'Infinity' refers to a value, but is being used as a type here. Did you mean 'typeof Infinity'? + \ No newline at end of file diff --git a/tests/baselines/reference/fakeInfinity2.symbols b/tests/baselines/reference/fakeInfinity2.symbols new file mode 100644 index 0000000000000..3071165542447 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity2.symbols @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/fakeInfinity2.ts] //// + +=== fakeInfinity2.ts === +export enum Foo { +>Foo : Symbol(Foo, Decl(fakeInfinity2.ts, 0, 0)) + + A = 1e999, +>A : Symbol(Foo.A, Decl(fakeInfinity2.ts, 0, 17)) + + B = -1e999, +>B : Symbol(Foo.B, Decl(fakeInfinity2.ts, 1, 14)) +} + +namespace X { +>X : Symbol(X, Decl(fakeInfinity2.ts, 3, 1)) + + type A = 1e999; +>A : Symbol(A, Decl(fakeInfinity2.ts, 5, 13)) + + type B = 2e999; +>B : Symbol(B, Decl(fakeInfinity2.ts, 6, 19)) + + export function f(): A { +>f : Symbol(f, Decl(fakeInfinity2.ts, 7, 19)) +>A : Symbol(A, Decl(fakeInfinity2.ts, 5, 13)) + + throw new Error() +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } +} + +export const m = X.f(); +>m : Symbol(m, Decl(fakeInfinity2.ts, 14, 12)) +>X.f : Symbol(X.f, Decl(fakeInfinity2.ts, 7, 19)) +>X : Symbol(X, Decl(fakeInfinity2.ts, 3, 1)) +>f : Symbol(X.f, Decl(fakeInfinity2.ts, 7, 19)) + diff --git a/tests/baselines/reference/fakeInfinity2.types b/tests/baselines/reference/fakeInfinity2.types new file mode 100644 index 0000000000000..0303d2c1d1ef6 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity2.types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/fakeInfinity2.ts] //// + +=== fakeInfinity2.ts === +export enum Foo { +>Foo : Foo + + A = 1e999, +>A : Foo.A +>1e999 : Infinity + + B = -1e999, +>B : Foo.B +>-1e999 : -Infinity +>1e999 : Infinity +} + +namespace X { +>X : typeof X + + type A = 1e999; +>A : Infinity + + type B = 2e999; +>B : Infinity + + export function f(): A { +>f : () => Infinity + + throw new Error() +>new Error() : Error +>Error : ErrorConstructor + } +} + +export const m = X.f(); +>m : Infinity +>X.f() : Infinity +>X.f : () => Infinity +>X : typeof X +>f : () => Infinity + diff --git a/tests/baselines/reference/fakeInfinity3.js b/tests/baselines/reference/fakeInfinity3.js new file mode 100644 index 0000000000000..dbde9c2ce72b8 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity3.js @@ -0,0 +1,70 @@ +//// [tests/cases/compiler/fakeInfinity3.ts] //// + +//// [fakeInfinity3.ts] +export enum Foo { + A = 1e999, + B = -1e999, +} + +namespace X { + type A = 1e999; + type B = 2e999; + + export function f(): A { + throw new Error() + } +} + +export const m = X.f(); + +export const Infinity = "oops"; + + +//// [fakeInfinity3.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Infinity = exports.m = exports.Foo = void 0; +var Foo; +(function (Foo) { + Foo[Foo["A"] = Infinity] = "A"; + Foo[Foo["B"] = -Infinity] = "B"; +})(Foo || (exports.Foo = Foo = {})); +var X; +(function (X) { + function f() { + throw new Error(); + } + X.f = f; +})(X || (X = {})); +exports.m = X.f(); +exports.Infinity = "oops"; + + +//// [fakeInfinity3.d.ts] +export declare enum Foo { + A = Infinity, + B = -Infinity +} +export declare const m: Infinity; +export declare const Infinity = "oops"; + + +//// [DtsFileErrors] + + +fakeInfinity3.d.ts(3,9): error TS1066: In ambient enum declarations member initializer must be constant expression. +fakeInfinity3.d.ts(5,25): error TS2749: 'Infinity' refers to a value, but is being used as a type here. Did you mean 'typeof Infinity'? + + +==== fakeInfinity3.d.ts (2 errors) ==== + export declare enum Foo { + A = Infinity, + B = -Infinity + ~~~~~~~~~ +!!! error TS1066: In ambient enum declarations member initializer must be constant expression. + } + export declare const m: Infinity; + ~~~~~~~~ +!!! error TS2749: 'Infinity' refers to a value, but is being used as a type here. Did you mean 'typeof Infinity'? + export declare const Infinity = "oops"; + \ No newline at end of file diff --git a/tests/baselines/reference/fakeInfinity3.symbols b/tests/baselines/reference/fakeInfinity3.symbols new file mode 100644 index 0000000000000..670ef0ee6521c --- /dev/null +++ b/tests/baselines/reference/fakeInfinity3.symbols @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/fakeInfinity3.ts] //// + +=== fakeInfinity3.ts === +export enum Foo { +>Foo : Symbol(Foo, Decl(fakeInfinity3.ts, 0, 0)) + + A = 1e999, +>A : Symbol(Foo.A, Decl(fakeInfinity3.ts, 0, 17)) + + B = -1e999, +>B : Symbol(Foo.B, Decl(fakeInfinity3.ts, 1, 14)) +} + +namespace X { +>X : Symbol(X, Decl(fakeInfinity3.ts, 3, 1)) + + type A = 1e999; +>A : Symbol(A, Decl(fakeInfinity3.ts, 5, 13)) + + type B = 2e999; +>B : Symbol(B, Decl(fakeInfinity3.ts, 6, 19)) + + export function f(): A { +>f : Symbol(f, Decl(fakeInfinity3.ts, 7, 19)) +>A : Symbol(A, Decl(fakeInfinity3.ts, 5, 13)) + + throw new Error() +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } +} + +export const m = X.f(); +>m : Symbol(m, Decl(fakeInfinity3.ts, 14, 12)) +>X.f : Symbol(X.f, Decl(fakeInfinity3.ts, 7, 19)) +>X : Symbol(X, Decl(fakeInfinity3.ts, 3, 1)) +>f : Symbol(X.f, Decl(fakeInfinity3.ts, 7, 19)) + +export const Infinity = "oops"; +>Infinity : Symbol(Infinity, Decl(fakeInfinity3.ts, 16, 12)) + diff --git a/tests/baselines/reference/fakeInfinity3.types b/tests/baselines/reference/fakeInfinity3.types new file mode 100644 index 0000000000000..30eb4d11a9a62 --- /dev/null +++ b/tests/baselines/reference/fakeInfinity3.types @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/fakeInfinity3.ts] //// + +=== fakeInfinity3.ts === +export enum Foo { +>Foo : Foo + + A = 1e999, +>A : Foo.A +>1e999 : Infinity + + B = -1e999, +>B : Foo.B +>-1e999 : -Infinity +>1e999 : Infinity +} + +namespace X { +>X : typeof X + + type A = 1e999; +>A : Infinity + + type B = 2e999; +>B : Infinity + + export function f(): A { +>f : () => Infinity + + throw new Error() +>new Error() : Error +>Error : ErrorConstructor + } +} + +export const m = X.f(); +>m : Infinity +>X.f() : Infinity +>X.f : () => Infinity +>X : typeof X +>f : () => Infinity + +export const Infinity = "oops"; +>Infinity : "oops" +>"oops" : "oops" + diff --git a/tests/baselines/reference/octalIntegerLiteral.types b/tests/baselines/reference/octalIntegerLiteral.types index 4ab8535089765..4d50a08d194f5 100644 --- a/tests/baselines/reference/octalIntegerLiteral.types +++ b/tests/baselines/reference/octalIntegerLiteral.types @@ -11,7 +11,7 @@ var oct2 = 0O45436; var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777; >oct3 : number ->0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777 : number +>0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777 : Infinity var oct4 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777; >oct4 : number diff --git a/tests/baselines/reference/octalIntegerLiteralES6.types b/tests/baselines/reference/octalIntegerLiteralES6.types index 45d9594d93f8c..d881232403701 100644 --- a/tests/baselines/reference/octalIntegerLiteralES6.types +++ b/tests/baselines/reference/octalIntegerLiteralES6.types @@ -11,7 +11,7 @@ var oct2 = 0O45436; var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777; >oct3 : number ->0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777 : number +>0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777 : Infinity var oct4 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777; >oct4 : number diff --git a/tests/baselines/reference/trackedSymbolsNoCrash.js b/tests/baselines/reference/trackedSymbolsNoCrash.js new file mode 100644 index 0000000000000..56a94d76230e6 --- /dev/null +++ b/tests/baselines/reference/trackedSymbolsNoCrash.js @@ -0,0 +1,946 @@ +//// [tests/cases/compiler/trackedSymbolsNoCrash.ts] //// + +//// [ast.ts] +export enum SyntaxKind { Node0, Node1, Node2, Node3, Node4, Node5, Node6, Node7, Node8, Node9, Node10, Node11, Node12, Node13, Node14, Node15, Node16, Node17, Node18, Node19, Node20, Node21, Node22, Node23, Node24, Node25, Node26, Node27, Node28, Node29, Node30, Node31, Node32, Node33, Node34, Node35, Node36, Node37, Node38, Node39, Node40, Node41, Node42, Node43, Node44, Node45, Node46, Node47, Node48, Node49, Node50, Node51, Node52, Node53, Node54, Node55, Node56, Node57, Node58, Node59, Node60, Node61, Node62, Node63, Node64, Node65, Node66, Node67, Node68, Node69, Node70, Node71, Node72, Node73, Node74, Node75, Node76, Node77, Node78, Node79, Node80, Node81, Node82, Node83, Node84, Node85, Node86, Node87, Node88, Node89, Node90, Node91, Node92, Node93, Node94, Node95, Node96, Node97, Node98, Node99 } + +export interface Node0 { kind: SyntaxKind.Node0; propNode0: number; } +export interface Node1 { kind: SyntaxKind.Node1; propNode1: number; } +export interface Node2 { kind: SyntaxKind.Node2; propNode2: number; } +export interface Node3 { kind: SyntaxKind.Node3; propNode3: number; } +export interface Node4 { kind: SyntaxKind.Node4; propNode4: number; } +export interface Node5 { kind: SyntaxKind.Node5; propNode5: number; } +export interface Node6 { kind: SyntaxKind.Node6; propNode6: number; } +export interface Node7 { kind: SyntaxKind.Node7; propNode7: number; } +export interface Node8 { kind: SyntaxKind.Node8; propNode8: number; } +export interface Node9 { kind: SyntaxKind.Node9; propNode9: number; } +export interface Node10 { kind: SyntaxKind.Node10; propNode10: number; } +export interface Node11 { kind: SyntaxKind.Node11; propNode11: number; } +export interface Node12 { kind: SyntaxKind.Node12; propNode12: number; } +export interface Node13 { kind: SyntaxKind.Node13; propNode13: number; } +export interface Node14 { kind: SyntaxKind.Node14; propNode14: number; } +export interface Node15 { kind: SyntaxKind.Node15; propNode15: number; } +export interface Node16 { kind: SyntaxKind.Node16; propNode16: number; } +export interface Node17 { kind: SyntaxKind.Node17; propNode17: number; } +export interface Node18 { kind: SyntaxKind.Node18; propNode18: number; } +export interface Node19 { kind: SyntaxKind.Node19; propNode19: number; } +export interface Node20 { kind: SyntaxKind.Node20; propNode20: number; } +export interface Node21 { kind: SyntaxKind.Node21; propNode21: number; } +export interface Node22 { kind: SyntaxKind.Node22; propNode22: number; } +export interface Node23 { kind: SyntaxKind.Node23; propNode23: number; } +export interface Node24 { kind: SyntaxKind.Node24; propNode24: number; } +export interface Node25 { kind: SyntaxKind.Node25; propNode25: number; } +export interface Node26 { kind: SyntaxKind.Node26; propNode26: number; } +export interface Node27 { kind: SyntaxKind.Node27; propNode27: number; } +export interface Node28 { kind: SyntaxKind.Node28; propNode28: number; } +export interface Node29 { kind: SyntaxKind.Node29; propNode29: number; } +export interface Node30 { kind: SyntaxKind.Node30; propNode30: number; } +export interface Node31 { kind: SyntaxKind.Node31; propNode31: number; } +export interface Node32 { kind: SyntaxKind.Node32; propNode32: number; } +export interface Node33 { kind: SyntaxKind.Node33; propNode33: number; } +export interface Node34 { kind: SyntaxKind.Node34; propNode34: number; } +export interface Node35 { kind: SyntaxKind.Node35; propNode35: number; } +export interface Node36 { kind: SyntaxKind.Node36; propNode36: number; } +export interface Node37 { kind: SyntaxKind.Node37; propNode37: number; } +export interface Node38 { kind: SyntaxKind.Node38; propNode38: number; } +export interface Node39 { kind: SyntaxKind.Node39; propNode39: number; } +export interface Node40 { kind: SyntaxKind.Node40; propNode40: number; } +export interface Node41 { kind: SyntaxKind.Node41; propNode41: number; } +export interface Node42 { kind: SyntaxKind.Node42; propNode42: number; } +export interface Node43 { kind: SyntaxKind.Node43; propNode43: number; } +export interface Node44 { kind: SyntaxKind.Node44; propNode44: number; } +export interface Node45 { kind: SyntaxKind.Node45; propNode45: number; } +export interface Node46 { kind: SyntaxKind.Node46; propNode46: number; } +export interface Node47 { kind: SyntaxKind.Node47; propNode47: number; } +export interface Node48 { kind: SyntaxKind.Node48; propNode48: number; } +export interface Node49 { kind: SyntaxKind.Node49; propNode49: number; } +export interface Node50 { kind: SyntaxKind.Node50; propNode50: number; } +export interface Node51 { kind: SyntaxKind.Node51; propNode51: number; } +export interface Node52 { kind: SyntaxKind.Node52; propNode52: number; } +export interface Node53 { kind: SyntaxKind.Node53; propNode53: number; } +export interface Node54 { kind: SyntaxKind.Node54; propNode54: number; } +export interface Node55 { kind: SyntaxKind.Node55; propNode55: number; } +export interface Node56 { kind: SyntaxKind.Node56; propNode56: number; } +export interface Node57 { kind: SyntaxKind.Node57; propNode57: number; } +export interface Node58 { kind: SyntaxKind.Node58; propNode58: number; } +export interface Node59 { kind: SyntaxKind.Node59; propNode59: number; } +export interface Node60 { kind: SyntaxKind.Node60; propNode60: number; } +export interface Node61 { kind: SyntaxKind.Node61; propNode61: number; } +export interface Node62 { kind: SyntaxKind.Node62; propNode62: number; } +export interface Node63 { kind: SyntaxKind.Node63; propNode63: number; } +export interface Node64 { kind: SyntaxKind.Node64; propNode64: number; } +export interface Node65 { kind: SyntaxKind.Node65; propNode65: number; } +export interface Node66 { kind: SyntaxKind.Node66; propNode66: number; } +export interface Node67 { kind: SyntaxKind.Node67; propNode67: number; } +export interface Node68 { kind: SyntaxKind.Node68; propNode68: number; } +export interface Node69 { kind: SyntaxKind.Node69; propNode69: number; } +export interface Node70 { kind: SyntaxKind.Node70; propNode70: number; } +export interface Node71 { kind: SyntaxKind.Node71; propNode71: number; } +export interface Node72 { kind: SyntaxKind.Node72; propNode72: number; } +export interface Node73 { kind: SyntaxKind.Node73; propNode73: number; } +export interface Node74 { kind: SyntaxKind.Node74; propNode74: number; } +export interface Node75 { kind: SyntaxKind.Node75; propNode75: number; } +export interface Node76 { kind: SyntaxKind.Node76; propNode76: number; } +export interface Node77 { kind: SyntaxKind.Node77; propNode77: number; } +export interface Node78 { kind: SyntaxKind.Node78; propNode78: number; } +export interface Node79 { kind: SyntaxKind.Node79; propNode79: number; } +export interface Node80 { kind: SyntaxKind.Node80; propNode80: number; } +export interface Node81 { kind: SyntaxKind.Node81; propNode81: number; } +export interface Node82 { kind: SyntaxKind.Node82; propNode82: number; } +export interface Node83 { kind: SyntaxKind.Node83; propNode83: number; } +export interface Node84 { kind: SyntaxKind.Node84; propNode84: number; } +export interface Node85 { kind: SyntaxKind.Node85; propNode85: number; } +export interface Node86 { kind: SyntaxKind.Node86; propNode86: number; } +export interface Node87 { kind: SyntaxKind.Node87; propNode87: number; } +export interface Node88 { kind: SyntaxKind.Node88; propNode88: number; } +export interface Node89 { kind: SyntaxKind.Node89; propNode89: number; } +export interface Node90 { kind: SyntaxKind.Node90; propNode90: number; } +export interface Node91 { kind: SyntaxKind.Node91; propNode91: number; } +export interface Node92 { kind: SyntaxKind.Node92; propNode92: number; } +export interface Node93 { kind: SyntaxKind.Node93; propNode93: number; } +export interface Node94 { kind: SyntaxKind.Node94; propNode94: number; } +export interface Node95 { kind: SyntaxKind.Node95; propNode95: number; } +export interface Node96 { kind: SyntaxKind.Node96; propNode96: number; } +export interface Node97 { kind: SyntaxKind.Node97; propNode97: number; } +export interface Node98 { kind: SyntaxKind.Node98; propNode98: number; } +export interface Node99 { kind: SyntaxKind.Node99; propNode99: number; } + +export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node34 | Node35 | Node36 | Node37 | Node38 | Node39 | Node40 | Node41 | Node42 | Node43 | Node44 | Node45 | Node46 | Node47 | Node48 | Node49 | Node50 | Node51 | Node52 | Node53 | Node54 | Node55 | Node56 | Node57 | Node58 | Node59 | Node60 | Node61 | Node62 | Node63 | Node64 | Node65 | Node66 | Node67 | Node68 | Node69 | Node70 | Node71 | Node72 | Node73 | Node74 | Node75 | Node76 | Node77 | Node78 | Node79 | Node80 | Node81 | Node82 | Node83 | Node84 | Node85 | Node86 | Node87 | Node88 | Node89 | Node90 | Node91 | Node92 | Node93 | Node94 | Node95 | Node96 | Node97 | Node98 | Node99; + +//// [index.ts] +import * as ast from "./ast"; + +export const isNodeOfType = + (nodeType: NodeType) => + ( + node: ast.Node | null | undefined, + ): node is Extract => + node?.kind === nodeType; + + + +//// [ast.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SyntaxKind = void 0; +var SyntaxKind; +(function (SyntaxKind) { + SyntaxKind[SyntaxKind["Node0"] = 0] = "Node0"; + SyntaxKind[SyntaxKind["Node1"] = 1] = "Node1"; + SyntaxKind[SyntaxKind["Node2"] = 2] = "Node2"; + SyntaxKind[SyntaxKind["Node3"] = 3] = "Node3"; + SyntaxKind[SyntaxKind["Node4"] = 4] = "Node4"; + SyntaxKind[SyntaxKind["Node5"] = 5] = "Node5"; + SyntaxKind[SyntaxKind["Node6"] = 6] = "Node6"; + SyntaxKind[SyntaxKind["Node7"] = 7] = "Node7"; + SyntaxKind[SyntaxKind["Node8"] = 8] = "Node8"; + SyntaxKind[SyntaxKind["Node9"] = 9] = "Node9"; + SyntaxKind[SyntaxKind["Node10"] = 10] = "Node10"; + SyntaxKind[SyntaxKind["Node11"] = 11] = "Node11"; + SyntaxKind[SyntaxKind["Node12"] = 12] = "Node12"; + SyntaxKind[SyntaxKind["Node13"] = 13] = "Node13"; + SyntaxKind[SyntaxKind["Node14"] = 14] = "Node14"; + SyntaxKind[SyntaxKind["Node15"] = 15] = "Node15"; + SyntaxKind[SyntaxKind["Node16"] = 16] = "Node16"; + SyntaxKind[SyntaxKind["Node17"] = 17] = "Node17"; + SyntaxKind[SyntaxKind["Node18"] = 18] = "Node18"; + SyntaxKind[SyntaxKind["Node19"] = 19] = "Node19"; + SyntaxKind[SyntaxKind["Node20"] = 20] = "Node20"; + SyntaxKind[SyntaxKind["Node21"] = 21] = "Node21"; + SyntaxKind[SyntaxKind["Node22"] = 22] = "Node22"; + SyntaxKind[SyntaxKind["Node23"] = 23] = "Node23"; + SyntaxKind[SyntaxKind["Node24"] = 24] = "Node24"; + SyntaxKind[SyntaxKind["Node25"] = 25] = "Node25"; + SyntaxKind[SyntaxKind["Node26"] = 26] = "Node26"; + SyntaxKind[SyntaxKind["Node27"] = 27] = "Node27"; + SyntaxKind[SyntaxKind["Node28"] = 28] = "Node28"; + SyntaxKind[SyntaxKind["Node29"] = 29] = "Node29"; + SyntaxKind[SyntaxKind["Node30"] = 30] = "Node30"; + SyntaxKind[SyntaxKind["Node31"] = 31] = "Node31"; + SyntaxKind[SyntaxKind["Node32"] = 32] = "Node32"; + SyntaxKind[SyntaxKind["Node33"] = 33] = "Node33"; + SyntaxKind[SyntaxKind["Node34"] = 34] = "Node34"; + SyntaxKind[SyntaxKind["Node35"] = 35] = "Node35"; + SyntaxKind[SyntaxKind["Node36"] = 36] = "Node36"; + SyntaxKind[SyntaxKind["Node37"] = 37] = "Node37"; + SyntaxKind[SyntaxKind["Node38"] = 38] = "Node38"; + SyntaxKind[SyntaxKind["Node39"] = 39] = "Node39"; + SyntaxKind[SyntaxKind["Node40"] = 40] = "Node40"; + SyntaxKind[SyntaxKind["Node41"] = 41] = "Node41"; + SyntaxKind[SyntaxKind["Node42"] = 42] = "Node42"; + SyntaxKind[SyntaxKind["Node43"] = 43] = "Node43"; + SyntaxKind[SyntaxKind["Node44"] = 44] = "Node44"; + SyntaxKind[SyntaxKind["Node45"] = 45] = "Node45"; + SyntaxKind[SyntaxKind["Node46"] = 46] = "Node46"; + SyntaxKind[SyntaxKind["Node47"] = 47] = "Node47"; + SyntaxKind[SyntaxKind["Node48"] = 48] = "Node48"; + SyntaxKind[SyntaxKind["Node49"] = 49] = "Node49"; + SyntaxKind[SyntaxKind["Node50"] = 50] = "Node50"; + SyntaxKind[SyntaxKind["Node51"] = 51] = "Node51"; + SyntaxKind[SyntaxKind["Node52"] = 52] = "Node52"; + SyntaxKind[SyntaxKind["Node53"] = 53] = "Node53"; + SyntaxKind[SyntaxKind["Node54"] = 54] = "Node54"; + SyntaxKind[SyntaxKind["Node55"] = 55] = "Node55"; + SyntaxKind[SyntaxKind["Node56"] = 56] = "Node56"; + SyntaxKind[SyntaxKind["Node57"] = 57] = "Node57"; + SyntaxKind[SyntaxKind["Node58"] = 58] = "Node58"; + SyntaxKind[SyntaxKind["Node59"] = 59] = "Node59"; + SyntaxKind[SyntaxKind["Node60"] = 60] = "Node60"; + SyntaxKind[SyntaxKind["Node61"] = 61] = "Node61"; + SyntaxKind[SyntaxKind["Node62"] = 62] = "Node62"; + SyntaxKind[SyntaxKind["Node63"] = 63] = "Node63"; + SyntaxKind[SyntaxKind["Node64"] = 64] = "Node64"; + SyntaxKind[SyntaxKind["Node65"] = 65] = "Node65"; + SyntaxKind[SyntaxKind["Node66"] = 66] = "Node66"; + SyntaxKind[SyntaxKind["Node67"] = 67] = "Node67"; + SyntaxKind[SyntaxKind["Node68"] = 68] = "Node68"; + SyntaxKind[SyntaxKind["Node69"] = 69] = "Node69"; + SyntaxKind[SyntaxKind["Node70"] = 70] = "Node70"; + SyntaxKind[SyntaxKind["Node71"] = 71] = "Node71"; + SyntaxKind[SyntaxKind["Node72"] = 72] = "Node72"; + SyntaxKind[SyntaxKind["Node73"] = 73] = "Node73"; + SyntaxKind[SyntaxKind["Node74"] = 74] = "Node74"; + SyntaxKind[SyntaxKind["Node75"] = 75] = "Node75"; + SyntaxKind[SyntaxKind["Node76"] = 76] = "Node76"; + SyntaxKind[SyntaxKind["Node77"] = 77] = "Node77"; + SyntaxKind[SyntaxKind["Node78"] = 78] = "Node78"; + SyntaxKind[SyntaxKind["Node79"] = 79] = "Node79"; + SyntaxKind[SyntaxKind["Node80"] = 80] = "Node80"; + SyntaxKind[SyntaxKind["Node81"] = 81] = "Node81"; + SyntaxKind[SyntaxKind["Node82"] = 82] = "Node82"; + SyntaxKind[SyntaxKind["Node83"] = 83] = "Node83"; + SyntaxKind[SyntaxKind["Node84"] = 84] = "Node84"; + SyntaxKind[SyntaxKind["Node85"] = 85] = "Node85"; + SyntaxKind[SyntaxKind["Node86"] = 86] = "Node86"; + SyntaxKind[SyntaxKind["Node87"] = 87] = "Node87"; + SyntaxKind[SyntaxKind["Node88"] = 88] = "Node88"; + SyntaxKind[SyntaxKind["Node89"] = 89] = "Node89"; + SyntaxKind[SyntaxKind["Node90"] = 90] = "Node90"; + SyntaxKind[SyntaxKind["Node91"] = 91] = "Node91"; + SyntaxKind[SyntaxKind["Node92"] = 92] = "Node92"; + SyntaxKind[SyntaxKind["Node93"] = 93] = "Node93"; + SyntaxKind[SyntaxKind["Node94"] = 94] = "Node94"; + SyntaxKind[SyntaxKind["Node95"] = 95] = "Node95"; + SyntaxKind[SyntaxKind["Node96"] = 96] = "Node96"; + SyntaxKind[SyntaxKind["Node97"] = 97] = "Node97"; + SyntaxKind[SyntaxKind["Node98"] = 98] = "Node98"; + SyntaxKind[SyntaxKind["Node99"] = 99] = "Node99"; +})(SyntaxKind || (exports.SyntaxKind = SyntaxKind = {})); +//// [index.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isNodeOfType = void 0; +var isNodeOfType = function (nodeType) { + return function (node) { + return (node === null || node === void 0 ? void 0 : node.kind) === nodeType; + }; +}; +exports.isNodeOfType = isNodeOfType; + + +//// [ast.d.ts] +export declare enum SyntaxKind { + Node0 = 0, + Node1 = 1, + Node2 = 2, + Node3 = 3, + Node4 = 4, + Node5 = 5, + Node6 = 6, + Node7 = 7, + Node8 = 8, + Node9 = 9, + Node10 = 10, + Node11 = 11, + Node12 = 12, + Node13 = 13, + Node14 = 14, + Node15 = 15, + Node16 = 16, + Node17 = 17, + Node18 = 18, + Node19 = 19, + Node20 = 20, + Node21 = 21, + Node22 = 22, + Node23 = 23, + Node24 = 24, + Node25 = 25, + Node26 = 26, + Node27 = 27, + Node28 = 28, + Node29 = 29, + Node30 = 30, + Node31 = 31, + Node32 = 32, + Node33 = 33, + Node34 = 34, + Node35 = 35, + Node36 = 36, + Node37 = 37, + Node38 = 38, + Node39 = 39, + Node40 = 40, + Node41 = 41, + Node42 = 42, + Node43 = 43, + Node44 = 44, + Node45 = 45, + Node46 = 46, + Node47 = 47, + Node48 = 48, + Node49 = 49, + Node50 = 50, + Node51 = 51, + Node52 = 52, + Node53 = 53, + Node54 = 54, + Node55 = 55, + Node56 = 56, + Node57 = 57, + Node58 = 58, + Node59 = 59, + Node60 = 60, + Node61 = 61, + Node62 = 62, + Node63 = 63, + Node64 = 64, + Node65 = 65, + Node66 = 66, + Node67 = 67, + Node68 = 68, + Node69 = 69, + Node70 = 70, + Node71 = 71, + Node72 = 72, + Node73 = 73, + Node74 = 74, + Node75 = 75, + Node76 = 76, + Node77 = 77, + Node78 = 78, + Node79 = 79, + Node80 = 80, + Node81 = 81, + Node82 = 82, + Node83 = 83, + Node84 = 84, + Node85 = 85, + Node86 = 86, + Node87 = 87, + Node88 = 88, + Node89 = 89, + Node90 = 90, + Node91 = 91, + Node92 = 92, + Node93 = 93, + Node94 = 94, + Node95 = 95, + Node96 = 96, + Node97 = 97, + Node98 = 98, + Node99 = 99 +} +export interface Node0 { + kind: SyntaxKind.Node0; + propNode0: number; +} +export interface Node1 { + kind: SyntaxKind.Node1; + propNode1: number; +} +export interface Node2 { + kind: SyntaxKind.Node2; + propNode2: number; +} +export interface Node3 { + kind: SyntaxKind.Node3; + propNode3: number; +} +export interface Node4 { + kind: SyntaxKind.Node4; + propNode4: number; +} +export interface Node5 { + kind: SyntaxKind.Node5; + propNode5: number; +} +export interface Node6 { + kind: SyntaxKind.Node6; + propNode6: number; +} +export interface Node7 { + kind: SyntaxKind.Node7; + propNode7: number; +} +export interface Node8 { + kind: SyntaxKind.Node8; + propNode8: number; +} +export interface Node9 { + kind: SyntaxKind.Node9; + propNode9: number; +} +export interface Node10 { + kind: SyntaxKind.Node10; + propNode10: number; +} +export interface Node11 { + kind: SyntaxKind.Node11; + propNode11: number; +} +export interface Node12 { + kind: SyntaxKind.Node12; + propNode12: number; +} +export interface Node13 { + kind: SyntaxKind.Node13; + propNode13: number; +} +export interface Node14 { + kind: SyntaxKind.Node14; + propNode14: number; +} +export interface Node15 { + kind: SyntaxKind.Node15; + propNode15: number; +} +export interface Node16 { + kind: SyntaxKind.Node16; + propNode16: number; +} +export interface Node17 { + kind: SyntaxKind.Node17; + propNode17: number; +} +export interface Node18 { + kind: SyntaxKind.Node18; + propNode18: number; +} +export interface Node19 { + kind: SyntaxKind.Node19; + propNode19: number; +} +export interface Node20 { + kind: SyntaxKind.Node20; + propNode20: number; +} +export interface Node21 { + kind: SyntaxKind.Node21; + propNode21: number; +} +export interface Node22 { + kind: SyntaxKind.Node22; + propNode22: number; +} +export interface Node23 { + kind: SyntaxKind.Node23; + propNode23: number; +} +export interface Node24 { + kind: SyntaxKind.Node24; + propNode24: number; +} +export interface Node25 { + kind: SyntaxKind.Node25; + propNode25: number; +} +export interface Node26 { + kind: SyntaxKind.Node26; + propNode26: number; +} +export interface Node27 { + kind: SyntaxKind.Node27; + propNode27: number; +} +export interface Node28 { + kind: SyntaxKind.Node28; + propNode28: number; +} +export interface Node29 { + kind: SyntaxKind.Node29; + propNode29: number; +} +export interface Node30 { + kind: SyntaxKind.Node30; + propNode30: number; +} +export interface Node31 { + kind: SyntaxKind.Node31; + propNode31: number; +} +export interface Node32 { + kind: SyntaxKind.Node32; + propNode32: number; +} +export interface Node33 { + kind: SyntaxKind.Node33; + propNode33: number; +} +export interface Node34 { + kind: SyntaxKind.Node34; + propNode34: number; +} +export interface Node35 { + kind: SyntaxKind.Node35; + propNode35: number; +} +export interface Node36 { + kind: SyntaxKind.Node36; + propNode36: number; +} +export interface Node37 { + kind: SyntaxKind.Node37; + propNode37: number; +} +export interface Node38 { + kind: SyntaxKind.Node38; + propNode38: number; +} +export interface Node39 { + kind: SyntaxKind.Node39; + propNode39: number; +} +export interface Node40 { + kind: SyntaxKind.Node40; + propNode40: number; +} +export interface Node41 { + kind: SyntaxKind.Node41; + propNode41: number; +} +export interface Node42 { + kind: SyntaxKind.Node42; + propNode42: number; +} +export interface Node43 { + kind: SyntaxKind.Node43; + propNode43: number; +} +export interface Node44 { + kind: SyntaxKind.Node44; + propNode44: number; +} +export interface Node45 { + kind: SyntaxKind.Node45; + propNode45: number; +} +export interface Node46 { + kind: SyntaxKind.Node46; + propNode46: number; +} +export interface Node47 { + kind: SyntaxKind.Node47; + propNode47: number; +} +export interface Node48 { + kind: SyntaxKind.Node48; + propNode48: number; +} +export interface Node49 { + kind: SyntaxKind.Node49; + propNode49: number; +} +export interface Node50 { + kind: SyntaxKind.Node50; + propNode50: number; +} +export interface Node51 { + kind: SyntaxKind.Node51; + propNode51: number; +} +export interface Node52 { + kind: SyntaxKind.Node52; + propNode52: number; +} +export interface Node53 { + kind: SyntaxKind.Node53; + propNode53: number; +} +export interface Node54 { + kind: SyntaxKind.Node54; + propNode54: number; +} +export interface Node55 { + kind: SyntaxKind.Node55; + propNode55: number; +} +export interface Node56 { + kind: SyntaxKind.Node56; + propNode56: number; +} +export interface Node57 { + kind: SyntaxKind.Node57; + propNode57: number; +} +export interface Node58 { + kind: SyntaxKind.Node58; + propNode58: number; +} +export interface Node59 { + kind: SyntaxKind.Node59; + propNode59: number; +} +export interface Node60 { + kind: SyntaxKind.Node60; + propNode60: number; +} +export interface Node61 { + kind: SyntaxKind.Node61; + propNode61: number; +} +export interface Node62 { + kind: SyntaxKind.Node62; + propNode62: number; +} +export interface Node63 { + kind: SyntaxKind.Node63; + propNode63: number; +} +export interface Node64 { + kind: SyntaxKind.Node64; + propNode64: number; +} +export interface Node65 { + kind: SyntaxKind.Node65; + propNode65: number; +} +export interface Node66 { + kind: SyntaxKind.Node66; + propNode66: number; +} +export interface Node67 { + kind: SyntaxKind.Node67; + propNode67: number; +} +export interface Node68 { + kind: SyntaxKind.Node68; + propNode68: number; +} +export interface Node69 { + kind: SyntaxKind.Node69; + propNode69: number; +} +export interface Node70 { + kind: SyntaxKind.Node70; + propNode70: number; +} +export interface Node71 { + kind: SyntaxKind.Node71; + propNode71: number; +} +export interface Node72 { + kind: SyntaxKind.Node72; + propNode72: number; +} +export interface Node73 { + kind: SyntaxKind.Node73; + propNode73: number; +} +export interface Node74 { + kind: SyntaxKind.Node74; + propNode74: number; +} +export interface Node75 { + kind: SyntaxKind.Node75; + propNode75: number; +} +export interface Node76 { + kind: SyntaxKind.Node76; + propNode76: number; +} +export interface Node77 { + kind: SyntaxKind.Node77; + propNode77: number; +} +export interface Node78 { + kind: SyntaxKind.Node78; + propNode78: number; +} +export interface Node79 { + kind: SyntaxKind.Node79; + propNode79: number; +} +export interface Node80 { + kind: SyntaxKind.Node80; + propNode80: number; +} +export interface Node81 { + kind: SyntaxKind.Node81; + propNode81: number; +} +export interface Node82 { + kind: SyntaxKind.Node82; + propNode82: number; +} +export interface Node83 { + kind: SyntaxKind.Node83; + propNode83: number; +} +export interface Node84 { + kind: SyntaxKind.Node84; + propNode84: number; +} +export interface Node85 { + kind: SyntaxKind.Node85; + propNode85: number; +} +export interface Node86 { + kind: SyntaxKind.Node86; + propNode86: number; +} +export interface Node87 { + kind: SyntaxKind.Node87; + propNode87: number; +} +export interface Node88 { + kind: SyntaxKind.Node88; + propNode88: number; +} +export interface Node89 { + kind: SyntaxKind.Node89; + propNode89: number; +} +export interface Node90 { + kind: SyntaxKind.Node90; + propNode90: number; +} +export interface Node91 { + kind: SyntaxKind.Node91; + propNode91: number; +} +export interface Node92 { + kind: SyntaxKind.Node92; + propNode92: number; +} +export interface Node93 { + kind: SyntaxKind.Node93; + propNode93: number; +} +export interface Node94 { + kind: SyntaxKind.Node94; + propNode94: number; +} +export interface Node95 { + kind: SyntaxKind.Node95; + propNode95: number; +} +export interface Node96 { + kind: SyntaxKind.Node96; + propNode96: number; +} +export interface Node97 { + kind: SyntaxKind.Node97; + propNode97: number; +} +export interface Node98 { + kind: SyntaxKind.Node98; + propNode98: number; +} +export interface Node99 { + kind: SyntaxKind.Node99; + propNode99: number; +} +export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node34 | Node35 | Node36 | Node37 | Node38 | Node39 | Node40 | Node41 | Node42 | Node43 | Node44 | Node45 | Node46 | Node47 | Node48 | Node49 | Node50 | Node51 | Node52 | Node53 | Node54 | Node55 | Node56 | Node57 | Node58 | Node59 | Node60 | Node61 | Node62 | Node63 | Node64 | Node65 | Node66 | Node67 | Node68 | Node69 | Node70 | Node71 | Node72 | Node73 | Node74 | Node75 | Node76 | Node77 | Node78 | Node79 | Node80 | Node81 | Node82 | Node83 | Node84 | Node85 | Node86 | Node87 | Node88 | Node89 | Node90 | Node91 | Node92 | Node93 | Node94 | Node95 | Node96 | Node97 | Node98 | Node99; +//// [index.d.ts] +import * as ast from "./ast"; +export declare const isNodeOfType: (nodeType: NodeType) => (node: ast.Node | null | undefined) => node is Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract; diff --git a/tests/baselines/reference/trackedSymbolsNoCrash.symbols b/tests/baselines/reference/trackedSymbolsNoCrash.symbols new file mode 100644 index 0000000000000..bb325aa6659cf --- /dev/null +++ b/tests/baselines/reference/trackedSymbolsNoCrash.symbols @@ -0,0 +1,944 @@ +//// [tests/cases/compiler/trackedSymbolsNoCrash.ts] //// + +=== ast.ts === +export enum SyntaxKind { Node0, Node1, Node2, Node3, Node4, Node5, Node6, Node7, Node8, Node9, Node10, Node11, Node12, Node13, Node14, Node15, Node16, Node17, Node18, Node19, Node20, Node21, Node22, Node23, Node24, Node25, Node26, Node27, Node28, Node29, Node30, Node31, Node32, Node33, Node34, Node35, Node36, Node37, Node38, Node39, Node40, Node41, Node42, Node43, Node44, Node45, Node46, Node47, Node48, Node49, Node50, Node51, Node52, Node53, Node54, Node55, Node56, Node57, Node58, Node59, Node60, Node61, Node62, Node63, Node64, Node65, Node66, Node67, Node68, Node69, Node70, Node71, Node72, Node73, Node74, Node75, Node76, Node77, Node78, Node79, Node80, Node81, Node82, Node83, Node84, Node85, Node86, Node87, Node88, Node89, Node90, Node91, Node92, Node93, Node94, Node95, Node96, Node97, Node98, Node99 } +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node0 : Symbol(SyntaxKind.Node0, Decl(ast.ts, 0, 24)) +>Node1 : Symbol(SyntaxKind.Node1, Decl(ast.ts, 0, 31)) +>Node2 : Symbol(SyntaxKind.Node2, Decl(ast.ts, 0, 38)) +>Node3 : Symbol(SyntaxKind.Node3, Decl(ast.ts, 0, 45)) +>Node4 : Symbol(SyntaxKind.Node4, Decl(ast.ts, 0, 52)) +>Node5 : Symbol(SyntaxKind.Node5, Decl(ast.ts, 0, 59)) +>Node6 : Symbol(SyntaxKind.Node6, Decl(ast.ts, 0, 66)) +>Node7 : Symbol(SyntaxKind.Node7, Decl(ast.ts, 0, 73)) +>Node8 : Symbol(SyntaxKind.Node8, Decl(ast.ts, 0, 80)) +>Node9 : Symbol(SyntaxKind.Node9, Decl(ast.ts, 0, 87)) +>Node10 : Symbol(SyntaxKind.Node10, Decl(ast.ts, 0, 94)) +>Node11 : Symbol(SyntaxKind.Node11, Decl(ast.ts, 0, 102)) +>Node12 : Symbol(SyntaxKind.Node12, Decl(ast.ts, 0, 110)) +>Node13 : Symbol(SyntaxKind.Node13, Decl(ast.ts, 0, 118)) +>Node14 : Symbol(SyntaxKind.Node14, Decl(ast.ts, 0, 126)) +>Node15 : Symbol(SyntaxKind.Node15, Decl(ast.ts, 0, 134)) +>Node16 : Symbol(SyntaxKind.Node16, Decl(ast.ts, 0, 142)) +>Node17 : Symbol(SyntaxKind.Node17, Decl(ast.ts, 0, 150)) +>Node18 : Symbol(SyntaxKind.Node18, Decl(ast.ts, 0, 158)) +>Node19 : Symbol(SyntaxKind.Node19, Decl(ast.ts, 0, 166)) +>Node20 : Symbol(SyntaxKind.Node20, Decl(ast.ts, 0, 174)) +>Node21 : Symbol(SyntaxKind.Node21, Decl(ast.ts, 0, 182)) +>Node22 : Symbol(SyntaxKind.Node22, Decl(ast.ts, 0, 190)) +>Node23 : Symbol(SyntaxKind.Node23, Decl(ast.ts, 0, 198)) +>Node24 : Symbol(SyntaxKind.Node24, Decl(ast.ts, 0, 206)) +>Node25 : Symbol(SyntaxKind.Node25, Decl(ast.ts, 0, 214)) +>Node26 : Symbol(SyntaxKind.Node26, Decl(ast.ts, 0, 222)) +>Node27 : Symbol(SyntaxKind.Node27, Decl(ast.ts, 0, 230)) +>Node28 : Symbol(SyntaxKind.Node28, Decl(ast.ts, 0, 238)) +>Node29 : Symbol(SyntaxKind.Node29, Decl(ast.ts, 0, 246)) +>Node30 : Symbol(SyntaxKind.Node30, Decl(ast.ts, 0, 254)) +>Node31 : Symbol(SyntaxKind.Node31, Decl(ast.ts, 0, 262)) +>Node32 : Symbol(SyntaxKind.Node32, Decl(ast.ts, 0, 270)) +>Node33 : Symbol(SyntaxKind.Node33, Decl(ast.ts, 0, 278)) +>Node34 : Symbol(SyntaxKind.Node34, Decl(ast.ts, 0, 286)) +>Node35 : Symbol(SyntaxKind.Node35, Decl(ast.ts, 0, 294)) +>Node36 : Symbol(SyntaxKind.Node36, Decl(ast.ts, 0, 302)) +>Node37 : Symbol(SyntaxKind.Node37, Decl(ast.ts, 0, 310)) +>Node38 : Symbol(SyntaxKind.Node38, Decl(ast.ts, 0, 318)) +>Node39 : Symbol(SyntaxKind.Node39, Decl(ast.ts, 0, 326)) +>Node40 : Symbol(SyntaxKind.Node40, Decl(ast.ts, 0, 334)) +>Node41 : Symbol(SyntaxKind.Node41, Decl(ast.ts, 0, 342)) +>Node42 : Symbol(SyntaxKind.Node42, Decl(ast.ts, 0, 350)) +>Node43 : Symbol(SyntaxKind.Node43, Decl(ast.ts, 0, 358)) +>Node44 : Symbol(SyntaxKind.Node44, Decl(ast.ts, 0, 366)) +>Node45 : Symbol(SyntaxKind.Node45, Decl(ast.ts, 0, 374)) +>Node46 : Symbol(SyntaxKind.Node46, Decl(ast.ts, 0, 382)) +>Node47 : Symbol(SyntaxKind.Node47, Decl(ast.ts, 0, 390)) +>Node48 : Symbol(SyntaxKind.Node48, Decl(ast.ts, 0, 398)) +>Node49 : Symbol(SyntaxKind.Node49, Decl(ast.ts, 0, 406)) +>Node50 : Symbol(SyntaxKind.Node50, Decl(ast.ts, 0, 414)) +>Node51 : Symbol(SyntaxKind.Node51, Decl(ast.ts, 0, 422)) +>Node52 : Symbol(SyntaxKind.Node52, Decl(ast.ts, 0, 430)) +>Node53 : Symbol(SyntaxKind.Node53, Decl(ast.ts, 0, 438)) +>Node54 : Symbol(SyntaxKind.Node54, Decl(ast.ts, 0, 446)) +>Node55 : Symbol(SyntaxKind.Node55, Decl(ast.ts, 0, 454)) +>Node56 : Symbol(SyntaxKind.Node56, Decl(ast.ts, 0, 462)) +>Node57 : Symbol(SyntaxKind.Node57, Decl(ast.ts, 0, 470)) +>Node58 : Symbol(SyntaxKind.Node58, Decl(ast.ts, 0, 478)) +>Node59 : Symbol(SyntaxKind.Node59, Decl(ast.ts, 0, 486)) +>Node60 : Symbol(SyntaxKind.Node60, Decl(ast.ts, 0, 494)) +>Node61 : Symbol(SyntaxKind.Node61, Decl(ast.ts, 0, 502)) +>Node62 : Symbol(SyntaxKind.Node62, Decl(ast.ts, 0, 510)) +>Node63 : Symbol(SyntaxKind.Node63, Decl(ast.ts, 0, 518)) +>Node64 : Symbol(SyntaxKind.Node64, Decl(ast.ts, 0, 526)) +>Node65 : Symbol(SyntaxKind.Node65, Decl(ast.ts, 0, 534)) +>Node66 : Symbol(SyntaxKind.Node66, Decl(ast.ts, 0, 542)) +>Node67 : Symbol(SyntaxKind.Node67, Decl(ast.ts, 0, 550)) +>Node68 : Symbol(SyntaxKind.Node68, Decl(ast.ts, 0, 558)) +>Node69 : Symbol(SyntaxKind.Node69, Decl(ast.ts, 0, 566)) +>Node70 : Symbol(SyntaxKind.Node70, Decl(ast.ts, 0, 574)) +>Node71 : Symbol(SyntaxKind.Node71, Decl(ast.ts, 0, 582)) +>Node72 : Symbol(SyntaxKind.Node72, Decl(ast.ts, 0, 590)) +>Node73 : Symbol(SyntaxKind.Node73, Decl(ast.ts, 0, 598)) +>Node74 : Symbol(SyntaxKind.Node74, Decl(ast.ts, 0, 606)) +>Node75 : Symbol(SyntaxKind.Node75, Decl(ast.ts, 0, 614)) +>Node76 : Symbol(SyntaxKind.Node76, Decl(ast.ts, 0, 622)) +>Node77 : Symbol(SyntaxKind.Node77, Decl(ast.ts, 0, 630)) +>Node78 : Symbol(SyntaxKind.Node78, Decl(ast.ts, 0, 638)) +>Node79 : Symbol(SyntaxKind.Node79, Decl(ast.ts, 0, 646)) +>Node80 : Symbol(SyntaxKind.Node80, Decl(ast.ts, 0, 654)) +>Node81 : Symbol(SyntaxKind.Node81, Decl(ast.ts, 0, 662)) +>Node82 : Symbol(SyntaxKind.Node82, Decl(ast.ts, 0, 670)) +>Node83 : Symbol(SyntaxKind.Node83, Decl(ast.ts, 0, 678)) +>Node84 : Symbol(SyntaxKind.Node84, Decl(ast.ts, 0, 686)) +>Node85 : Symbol(SyntaxKind.Node85, Decl(ast.ts, 0, 694)) +>Node86 : Symbol(SyntaxKind.Node86, Decl(ast.ts, 0, 702)) +>Node87 : Symbol(SyntaxKind.Node87, Decl(ast.ts, 0, 710)) +>Node88 : Symbol(SyntaxKind.Node88, Decl(ast.ts, 0, 718)) +>Node89 : Symbol(SyntaxKind.Node89, Decl(ast.ts, 0, 726)) +>Node90 : Symbol(SyntaxKind.Node90, Decl(ast.ts, 0, 734)) +>Node91 : Symbol(SyntaxKind.Node91, Decl(ast.ts, 0, 742)) +>Node92 : Symbol(SyntaxKind.Node92, Decl(ast.ts, 0, 750)) +>Node93 : Symbol(SyntaxKind.Node93, Decl(ast.ts, 0, 758)) +>Node94 : Symbol(SyntaxKind.Node94, Decl(ast.ts, 0, 766)) +>Node95 : Symbol(SyntaxKind.Node95, Decl(ast.ts, 0, 774)) +>Node96 : Symbol(SyntaxKind.Node96, Decl(ast.ts, 0, 782)) +>Node97 : Symbol(SyntaxKind.Node97, Decl(ast.ts, 0, 790)) +>Node98 : Symbol(SyntaxKind.Node98, Decl(ast.ts, 0, 798)) +>Node99 : Symbol(SyntaxKind.Node99, Decl(ast.ts, 0, 806)) + +export interface Node0 { kind: SyntaxKind.Node0; propNode0: number; } +>Node0 : Symbol(Node0, Decl(ast.ts, 0, 815)) +>kind : Symbol(Node0.kind, Decl(ast.ts, 2, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node0 : Symbol(SyntaxKind.Node0, Decl(ast.ts, 0, 24)) +>propNode0 : Symbol(Node0.propNode0, Decl(ast.ts, 2, 48)) + +export interface Node1 { kind: SyntaxKind.Node1; propNode1: number; } +>Node1 : Symbol(Node1, Decl(ast.ts, 2, 69)) +>kind : Symbol(Node1.kind, Decl(ast.ts, 3, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node1 : Symbol(SyntaxKind.Node1, Decl(ast.ts, 0, 31)) +>propNode1 : Symbol(Node1.propNode1, Decl(ast.ts, 3, 48)) + +export interface Node2 { kind: SyntaxKind.Node2; propNode2: number; } +>Node2 : Symbol(Node2, Decl(ast.ts, 3, 69)) +>kind : Symbol(Node2.kind, Decl(ast.ts, 4, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node2 : Symbol(SyntaxKind.Node2, Decl(ast.ts, 0, 38)) +>propNode2 : Symbol(Node2.propNode2, Decl(ast.ts, 4, 48)) + +export interface Node3 { kind: SyntaxKind.Node3; propNode3: number; } +>Node3 : Symbol(Node3, Decl(ast.ts, 4, 69)) +>kind : Symbol(Node3.kind, Decl(ast.ts, 5, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node3 : Symbol(SyntaxKind.Node3, Decl(ast.ts, 0, 45)) +>propNode3 : Symbol(Node3.propNode3, Decl(ast.ts, 5, 48)) + +export interface Node4 { kind: SyntaxKind.Node4; propNode4: number; } +>Node4 : Symbol(Node4, Decl(ast.ts, 5, 69)) +>kind : Symbol(Node4.kind, Decl(ast.ts, 6, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node4 : Symbol(SyntaxKind.Node4, Decl(ast.ts, 0, 52)) +>propNode4 : Symbol(Node4.propNode4, Decl(ast.ts, 6, 48)) + +export interface Node5 { kind: SyntaxKind.Node5; propNode5: number; } +>Node5 : Symbol(Node5, Decl(ast.ts, 6, 69)) +>kind : Symbol(Node5.kind, Decl(ast.ts, 7, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node5 : Symbol(SyntaxKind.Node5, Decl(ast.ts, 0, 59)) +>propNode5 : Symbol(Node5.propNode5, Decl(ast.ts, 7, 48)) + +export interface Node6 { kind: SyntaxKind.Node6; propNode6: number; } +>Node6 : Symbol(Node6, Decl(ast.ts, 7, 69)) +>kind : Symbol(Node6.kind, Decl(ast.ts, 8, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node6 : Symbol(SyntaxKind.Node6, Decl(ast.ts, 0, 66)) +>propNode6 : Symbol(Node6.propNode6, Decl(ast.ts, 8, 48)) + +export interface Node7 { kind: SyntaxKind.Node7; propNode7: number; } +>Node7 : Symbol(Node7, Decl(ast.ts, 8, 69)) +>kind : Symbol(Node7.kind, Decl(ast.ts, 9, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node7 : Symbol(SyntaxKind.Node7, Decl(ast.ts, 0, 73)) +>propNode7 : Symbol(Node7.propNode7, Decl(ast.ts, 9, 48)) + +export interface Node8 { kind: SyntaxKind.Node8; propNode8: number; } +>Node8 : Symbol(Node8, Decl(ast.ts, 9, 69)) +>kind : Symbol(Node8.kind, Decl(ast.ts, 10, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node8 : Symbol(SyntaxKind.Node8, Decl(ast.ts, 0, 80)) +>propNode8 : Symbol(Node8.propNode8, Decl(ast.ts, 10, 48)) + +export interface Node9 { kind: SyntaxKind.Node9; propNode9: number; } +>Node9 : Symbol(Node9, Decl(ast.ts, 10, 69)) +>kind : Symbol(Node9.kind, Decl(ast.ts, 11, 24)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node9 : Symbol(SyntaxKind.Node9, Decl(ast.ts, 0, 87)) +>propNode9 : Symbol(Node9.propNode9, Decl(ast.ts, 11, 48)) + +export interface Node10 { kind: SyntaxKind.Node10; propNode10: number; } +>Node10 : Symbol(Node10, Decl(ast.ts, 11, 69)) +>kind : Symbol(Node10.kind, Decl(ast.ts, 12, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node10 : Symbol(SyntaxKind.Node10, Decl(ast.ts, 0, 94)) +>propNode10 : Symbol(Node10.propNode10, Decl(ast.ts, 12, 50)) + +export interface Node11 { kind: SyntaxKind.Node11; propNode11: number; } +>Node11 : Symbol(Node11, Decl(ast.ts, 12, 72)) +>kind : Symbol(Node11.kind, Decl(ast.ts, 13, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node11 : Symbol(SyntaxKind.Node11, Decl(ast.ts, 0, 102)) +>propNode11 : Symbol(Node11.propNode11, Decl(ast.ts, 13, 50)) + +export interface Node12 { kind: SyntaxKind.Node12; propNode12: number; } +>Node12 : Symbol(Node12, Decl(ast.ts, 13, 72)) +>kind : Symbol(Node12.kind, Decl(ast.ts, 14, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node12 : Symbol(SyntaxKind.Node12, Decl(ast.ts, 0, 110)) +>propNode12 : Symbol(Node12.propNode12, Decl(ast.ts, 14, 50)) + +export interface Node13 { kind: SyntaxKind.Node13; propNode13: number; } +>Node13 : Symbol(Node13, Decl(ast.ts, 14, 72)) +>kind : Symbol(Node13.kind, Decl(ast.ts, 15, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node13 : Symbol(SyntaxKind.Node13, Decl(ast.ts, 0, 118)) +>propNode13 : Symbol(Node13.propNode13, Decl(ast.ts, 15, 50)) + +export interface Node14 { kind: SyntaxKind.Node14; propNode14: number; } +>Node14 : Symbol(Node14, Decl(ast.ts, 15, 72)) +>kind : Symbol(Node14.kind, Decl(ast.ts, 16, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node14 : Symbol(SyntaxKind.Node14, Decl(ast.ts, 0, 126)) +>propNode14 : Symbol(Node14.propNode14, Decl(ast.ts, 16, 50)) + +export interface Node15 { kind: SyntaxKind.Node15; propNode15: number; } +>Node15 : Symbol(Node15, Decl(ast.ts, 16, 72)) +>kind : Symbol(Node15.kind, Decl(ast.ts, 17, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node15 : Symbol(SyntaxKind.Node15, Decl(ast.ts, 0, 134)) +>propNode15 : Symbol(Node15.propNode15, Decl(ast.ts, 17, 50)) + +export interface Node16 { kind: SyntaxKind.Node16; propNode16: number; } +>Node16 : Symbol(Node16, Decl(ast.ts, 17, 72)) +>kind : Symbol(Node16.kind, Decl(ast.ts, 18, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node16 : Symbol(SyntaxKind.Node16, Decl(ast.ts, 0, 142)) +>propNode16 : Symbol(Node16.propNode16, Decl(ast.ts, 18, 50)) + +export interface Node17 { kind: SyntaxKind.Node17; propNode17: number; } +>Node17 : Symbol(Node17, Decl(ast.ts, 18, 72)) +>kind : Symbol(Node17.kind, Decl(ast.ts, 19, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node17 : Symbol(SyntaxKind.Node17, Decl(ast.ts, 0, 150)) +>propNode17 : Symbol(Node17.propNode17, Decl(ast.ts, 19, 50)) + +export interface Node18 { kind: SyntaxKind.Node18; propNode18: number; } +>Node18 : Symbol(Node18, Decl(ast.ts, 19, 72)) +>kind : Symbol(Node18.kind, Decl(ast.ts, 20, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node18 : Symbol(SyntaxKind.Node18, Decl(ast.ts, 0, 158)) +>propNode18 : Symbol(Node18.propNode18, Decl(ast.ts, 20, 50)) + +export interface Node19 { kind: SyntaxKind.Node19; propNode19: number; } +>Node19 : Symbol(Node19, Decl(ast.ts, 20, 72)) +>kind : Symbol(Node19.kind, Decl(ast.ts, 21, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node19 : Symbol(SyntaxKind.Node19, Decl(ast.ts, 0, 166)) +>propNode19 : Symbol(Node19.propNode19, Decl(ast.ts, 21, 50)) + +export interface Node20 { kind: SyntaxKind.Node20; propNode20: number; } +>Node20 : Symbol(Node20, Decl(ast.ts, 21, 72)) +>kind : Symbol(Node20.kind, Decl(ast.ts, 22, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node20 : Symbol(SyntaxKind.Node20, Decl(ast.ts, 0, 174)) +>propNode20 : Symbol(Node20.propNode20, Decl(ast.ts, 22, 50)) + +export interface Node21 { kind: SyntaxKind.Node21; propNode21: number; } +>Node21 : Symbol(Node21, Decl(ast.ts, 22, 72)) +>kind : Symbol(Node21.kind, Decl(ast.ts, 23, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node21 : Symbol(SyntaxKind.Node21, Decl(ast.ts, 0, 182)) +>propNode21 : Symbol(Node21.propNode21, Decl(ast.ts, 23, 50)) + +export interface Node22 { kind: SyntaxKind.Node22; propNode22: number; } +>Node22 : Symbol(Node22, Decl(ast.ts, 23, 72)) +>kind : Symbol(Node22.kind, Decl(ast.ts, 24, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node22 : Symbol(SyntaxKind.Node22, Decl(ast.ts, 0, 190)) +>propNode22 : Symbol(Node22.propNode22, Decl(ast.ts, 24, 50)) + +export interface Node23 { kind: SyntaxKind.Node23; propNode23: number; } +>Node23 : Symbol(Node23, Decl(ast.ts, 24, 72)) +>kind : Symbol(Node23.kind, Decl(ast.ts, 25, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node23 : Symbol(SyntaxKind.Node23, Decl(ast.ts, 0, 198)) +>propNode23 : Symbol(Node23.propNode23, Decl(ast.ts, 25, 50)) + +export interface Node24 { kind: SyntaxKind.Node24; propNode24: number; } +>Node24 : Symbol(Node24, Decl(ast.ts, 25, 72)) +>kind : Symbol(Node24.kind, Decl(ast.ts, 26, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node24 : Symbol(SyntaxKind.Node24, Decl(ast.ts, 0, 206)) +>propNode24 : Symbol(Node24.propNode24, Decl(ast.ts, 26, 50)) + +export interface Node25 { kind: SyntaxKind.Node25; propNode25: number; } +>Node25 : Symbol(Node25, Decl(ast.ts, 26, 72)) +>kind : Symbol(Node25.kind, Decl(ast.ts, 27, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node25 : Symbol(SyntaxKind.Node25, Decl(ast.ts, 0, 214)) +>propNode25 : Symbol(Node25.propNode25, Decl(ast.ts, 27, 50)) + +export interface Node26 { kind: SyntaxKind.Node26; propNode26: number; } +>Node26 : Symbol(Node26, Decl(ast.ts, 27, 72)) +>kind : Symbol(Node26.kind, Decl(ast.ts, 28, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node26 : Symbol(SyntaxKind.Node26, Decl(ast.ts, 0, 222)) +>propNode26 : Symbol(Node26.propNode26, Decl(ast.ts, 28, 50)) + +export interface Node27 { kind: SyntaxKind.Node27; propNode27: number; } +>Node27 : Symbol(Node27, Decl(ast.ts, 28, 72)) +>kind : Symbol(Node27.kind, Decl(ast.ts, 29, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node27 : Symbol(SyntaxKind.Node27, Decl(ast.ts, 0, 230)) +>propNode27 : Symbol(Node27.propNode27, Decl(ast.ts, 29, 50)) + +export interface Node28 { kind: SyntaxKind.Node28; propNode28: number; } +>Node28 : Symbol(Node28, Decl(ast.ts, 29, 72)) +>kind : Symbol(Node28.kind, Decl(ast.ts, 30, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node28 : Symbol(SyntaxKind.Node28, Decl(ast.ts, 0, 238)) +>propNode28 : Symbol(Node28.propNode28, Decl(ast.ts, 30, 50)) + +export interface Node29 { kind: SyntaxKind.Node29; propNode29: number; } +>Node29 : Symbol(Node29, Decl(ast.ts, 30, 72)) +>kind : Symbol(Node29.kind, Decl(ast.ts, 31, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node29 : Symbol(SyntaxKind.Node29, Decl(ast.ts, 0, 246)) +>propNode29 : Symbol(Node29.propNode29, Decl(ast.ts, 31, 50)) + +export interface Node30 { kind: SyntaxKind.Node30; propNode30: number; } +>Node30 : Symbol(Node30, Decl(ast.ts, 31, 72)) +>kind : Symbol(Node30.kind, Decl(ast.ts, 32, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node30 : Symbol(SyntaxKind.Node30, Decl(ast.ts, 0, 254)) +>propNode30 : Symbol(Node30.propNode30, Decl(ast.ts, 32, 50)) + +export interface Node31 { kind: SyntaxKind.Node31; propNode31: number; } +>Node31 : Symbol(Node31, Decl(ast.ts, 32, 72)) +>kind : Symbol(Node31.kind, Decl(ast.ts, 33, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node31 : Symbol(SyntaxKind.Node31, Decl(ast.ts, 0, 262)) +>propNode31 : Symbol(Node31.propNode31, Decl(ast.ts, 33, 50)) + +export interface Node32 { kind: SyntaxKind.Node32; propNode32: number; } +>Node32 : Symbol(Node32, Decl(ast.ts, 33, 72)) +>kind : Symbol(Node32.kind, Decl(ast.ts, 34, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node32 : Symbol(SyntaxKind.Node32, Decl(ast.ts, 0, 270)) +>propNode32 : Symbol(Node32.propNode32, Decl(ast.ts, 34, 50)) + +export interface Node33 { kind: SyntaxKind.Node33; propNode33: number; } +>Node33 : Symbol(Node33, Decl(ast.ts, 34, 72)) +>kind : Symbol(Node33.kind, Decl(ast.ts, 35, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node33 : Symbol(SyntaxKind.Node33, Decl(ast.ts, 0, 278)) +>propNode33 : Symbol(Node33.propNode33, Decl(ast.ts, 35, 50)) + +export interface Node34 { kind: SyntaxKind.Node34; propNode34: number; } +>Node34 : Symbol(Node34, Decl(ast.ts, 35, 72)) +>kind : Symbol(Node34.kind, Decl(ast.ts, 36, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node34 : Symbol(SyntaxKind.Node34, Decl(ast.ts, 0, 286)) +>propNode34 : Symbol(Node34.propNode34, Decl(ast.ts, 36, 50)) + +export interface Node35 { kind: SyntaxKind.Node35; propNode35: number; } +>Node35 : Symbol(Node35, Decl(ast.ts, 36, 72)) +>kind : Symbol(Node35.kind, Decl(ast.ts, 37, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node35 : Symbol(SyntaxKind.Node35, Decl(ast.ts, 0, 294)) +>propNode35 : Symbol(Node35.propNode35, Decl(ast.ts, 37, 50)) + +export interface Node36 { kind: SyntaxKind.Node36; propNode36: number; } +>Node36 : Symbol(Node36, Decl(ast.ts, 37, 72)) +>kind : Symbol(Node36.kind, Decl(ast.ts, 38, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node36 : Symbol(SyntaxKind.Node36, Decl(ast.ts, 0, 302)) +>propNode36 : Symbol(Node36.propNode36, Decl(ast.ts, 38, 50)) + +export interface Node37 { kind: SyntaxKind.Node37; propNode37: number; } +>Node37 : Symbol(Node37, Decl(ast.ts, 38, 72)) +>kind : Symbol(Node37.kind, Decl(ast.ts, 39, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node37 : Symbol(SyntaxKind.Node37, Decl(ast.ts, 0, 310)) +>propNode37 : Symbol(Node37.propNode37, Decl(ast.ts, 39, 50)) + +export interface Node38 { kind: SyntaxKind.Node38; propNode38: number; } +>Node38 : Symbol(Node38, Decl(ast.ts, 39, 72)) +>kind : Symbol(Node38.kind, Decl(ast.ts, 40, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node38 : Symbol(SyntaxKind.Node38, Decl(ast.ts, 0, 318)) +>propNode38 : Symbol(Node38.propNode38, Decl(ast.ts, 40, 50)) + +export interface Node39 { kind: SyntaxKind.Node39; propNode39: number; } +>Node39 : Symbol(Node39, Decl(ast.ts, 40, 72)) +>kind : Symbol(Node39.kind, Decl(ast.ts, 41, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node39 : Symbol(SyntaxKind.Node39, Decl(ast.ts, 0, 326)) +>propNode39 : Symbol(Node39.propNode39, Decl(ast.ts, 41, 50)) + +export interface Node40 { kind: SyntaxKind.Node40; propNode40: number; } +>Node40 : Symbol(Node40, Decl(ast.ts, 41, 72)) +>kind : Symbol(Node40.kind, Decl(ast.ts, 42, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node40 : Symbol(SyntaxKind.Node40, Decl(ast.ts, 0, 334)) +>propNode40 : Symbol(Node40.propNode40, Decl(ast.ts, 42, 50)) + +export interface Node41 { kind: SyntaxKind.Node41; propNode41: number; } +>Node41 : Symbol(Node41, Decl(ast.ts, 42, 72)) +>kind : Symbol(Node41.kind, Decl(ast.ts, 43, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node41 : Symbol(SyntaxKind.Node41, Decl(ast.ts, 0, 342)) +>propNode41 : Symbol(Node41.propNode41, Decl(ast.ts, 43, 50)) + +export interface Node42 { kind: SyntaxKind.Node42; propNode42: number; } +>Node42 : Symbol(Node42, Decl(ast.ts, 43, 72)) +>kind : Symbol(Node42.kind, Decl(ast.ts, 44, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node42 : Symbol(SyntaxKind.Node42, Decl(ast.ts, 0, 350)) +>propNode42 : Symbol(Node42.propNode42, Decl(ast.ts, 44, 50)) + +export interface Node43 { kind: SyntaxKind.Node43; propNode43: number; } +>Node43 : Symbol(Node43, Decl(ast.ts, 44, 72)) +>kind : Symbol(Node43.kind, Decl(ast.ts, 45, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node43 : Symbol(SyntaxKind.Node43, Decl(ast.ts, 0, 358)) +>propNode43 : Symbol(Node43.propNode43, Decl(ast.ts, 45, 50)) + +export interface Node44 { kind: SyntaxKind.Node44; propNode44: number; } +>Node44 : Symbol(Node44, Decl(ast.ts, 45, 72)) +>kind : Symbol(Node44.kind, Decl(ast.ts, 46, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node44 : Symbol(SyntaxKind.Node44, Decl(ast.ts, 0, 366)) +>propNode44 : Symbol(Node44.propNode44, Decl(ast.ts, 46, 50)) + +export interface Node45 { kind: SyntaxKind.Node45; propNode45: number; } +>Node45 : Symbol(Node45, Decl(ast.ts, 46, 72)) +>kind : Symbol(Node45.kind, Decl(ast.ts, 47, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node45 : Symbol(SyntaxKind.Node45, Decl(ast.ts, 0, 374)) +>propNode45 : Symbol(Node45.propNode45, Decl(ast.ts, 47, 50)) + +export interface Node46 { kind: SyntaxKind.Node46; propNode46: number; } +>Node46 : Symbol(Node46, Decl(ast.ts, 47, 72)) +>kind : Symbol(Node46.kind, Decl(ast.ts, 48, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node46 : Symbol(SyntaxKind.Node46, Decl(ast.ts, 0, 382)) +>propNode46 : Symbol(Node46.propNode46, Decl(ast.ts, 48, 50)) + +export interface Node47 { kind: SyntaxKind.Node47; propNode47: number; } +>Node47 : Symbol(Node47, Decl(ast.ts, 48, 72)) +>kind : Symbol(Node47.kind, Decl(ast.ts, 49, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node47 : Symbol(SyntaxKind.Node47, Decl(ast.ts, 0, 390)) +>propNode47 : Symbol(Node47.propNode47, Decl(ast.ts, 49, 50)) + +export interface Node48 { kind: SyntaxKind.Node48; propNode48: number; } +>Node48 : Symbol(Node48, Decl(ast.ts, 49, 72)) +>kind : Symbol(Node48.kind, Decl(ast.ts, 50, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node48 : Symbol(SyntaxKind.Node48, Decl(ast.ts, 0, 398)) +>propNode48 : Symbol(Node48.propNode48, Decl(ast.ts, 50, 50)) + +export interface Node49 { kind: SyntaxKind.Node49; propNode49: number; } +>Node49 : Symbol(Node49, Decl(ast.ts, 50, 72)) +>kind : Symbol(Node49.kind, Decl(ast.ts, 51, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node49 : Symbol(SyntaxKind.Node49, Decl(ast.ts, 0, 406)) +>propNode49 : Symbol(Node49.propNode49, Decl(ast.ts, 51, 50)) + +export interface Node50 { kind: SyntaxKind.Node50; propNode50: number; } +>Node50 : Symbol(Node50, Decl(ast.ts, 51, 72)) +>kind : Symbol(Node50.kind, Decl(ast.ts, 52, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node50 : Symbol(SyntaxKind.Node50, Decl(ast.ts, 0, 414)) +>propNode50 : Symbol(Node50.propNode50, Decl(ast.ts, 52, 50)) + +export interface Node51 { kind: SyntaxKind.Node51; propNode51: number; } +>Node51 : Symbol(Node51, Decl(ast.ts, 52, 72)) +>kind : Symbol(Node51.kind, Decl(ast.ts, 53, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node51 : Symbol(SyntaxKind.Node51, Decl(ast.ts, 0, 422)) +>propNode51 : Symbol(Node51.propNode51, Decl(ast.ts, 53, 50)) + +export interface Node52 { kind: SyntaxKind.Node52; propNode52: number; } +>Node52 : Symbol(Node52, Decl(ast.ts, 53, 72)) +>kind : Symbol(Node52.kind, Decl(ast.ts, 54, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node52 : Symbol(SyntaxKind.Node52, Decl(ast.ts, 0, 430)) +>propNode52 : Symbol(Node52.propNode52, Decl(ast.ts, 54, 50)) + +export interface Node53 { kind: SyntaxKind.Node53; propNode53: number; } +>Node53 : Symbol(Node53, Decl(ast.ts, 54, 72)) +>kind : Symbol(Node53.kind, Decl(ast.ts, 55, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node53 : Symbol(SyntaxKind.Node53, Decl(ast.ts, 0, 438)) +>propNode53 : Symbol(Node53.propNode53, Decl(ast.ts, 55, 50)) + +export interface Node54 { kind: SyntaxKind.Node54; propNode54: number; } +>Node54 : Symbol(Node54, Decl(ast.ts, 55, 72)) +>kind : Symbol(Node54.kind, Decl(ast.ts, 56, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node54 : Symbol(SyntaxKind.Node54, Decl(ast.ts, 0, 446)) +>propNode54 : Symbol(Node54.propNode54, Decl(ast.ts, 56, 50)) + +export interface Node55 { kind: SyntaxKind.Node55; propNode55: number; } +>Node55 : Symbol(Node55, Decl(ast.ts, 56, 72)) +>kind : Symbol(Node55.kind, Decl(ast.ts, 57, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node55 : Symbol(SyntaxKind.Node55, Decl(ast.ts, 0, 454)) +>propNode55 : Symbol(Node55.propNode55, Decl(ast.ts, 57, 50)) + +export interface Node56 { kind: SyntaxKind.Node56; propNode56: number; } +>Node56 : Symbol(Node56, Decl(ast.ts, 57, 72)) +>kind : Symbol(Node56.kind, Decl(ast.ts, 58, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node56 : Symbol(SyntaxKind.Node56, Decl(ast.ts, 0, 462)) +>propNode56 : Symbol(Node56.propNode56, Decl(ast.ts, 58, 50)) + +export interface Node57 { kind: SyntaxKind.Node57; propNode57: number; } +>Node57 : Symbol(Node57, Decl(ast.ts, 58, 72)) +>kind : Symbol(Node57.kind, Decl(ast.ts, 59, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node57 : Symbol(SyntaxKind.Node57, Decl(ast.ts, 0, 470)) +>propNode57 : Symbol(Node57.propNode57, Decl(ast.ts, 59, 50)) + +export interface Node58 { kind: SyntaxKind.Node58; propNode58: number; } +>Node58 : Symbol(Node58, Decl(ast.ts, 59, 72)) +>kind : Symbol(Node58.kind, Decl(ast.ts, 60, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node58 : Symbol(SyntaxKind.Node58, Decl(ast.ts, 0, 478)) +>propNode58 : Symbol(Node58.propNode58, Decl(ast.ts, 60, 50)) + +export interface Node59 { kind: SyntaxKind.Node59; propNode59: number; } +>Node59 : Symbol(Node59, Decl(ast.ts, 60, 72)) +>kind : Symbol(Node59.kind, Decl(ast.ts, 61, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node59 : Symbol(SyntaxKind.Node59, Decl(ast.ts, 0, 486)) +>propNode59 : Symbol(Node59.propNode59, Decl(ast.ts, 61, 50)) + +export interface Node60 { kind: SyntaxKind.Node60; propNode60: number; } +>Node60 : Symbol(Node60, Decl(ast.ts, 61, 72)) +>kind : Symbol(Node60.kind, Decl(ast.ts, 62, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node60 : Symbol(SyntaxKind.Node60, Decl(ast.ts, 0, 494)) +>propNode60 : Symbol(Node60.propNode60, Decl(ast.ts, 62, 50)) + +export interface Node61 { kind: SyntaxKind.Node61; propNode61: number; } +>Node61 : Symbol(Node61, Decl(ast.ts, 62, 72)) +>kind : Symbol(Node61.kind, Decl(ast.ts, 63, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node61 : Symbol(SyntaxKind.Node61, Decl(ast.ts, 0, 502)) +>propNode61 : Symbol(Node61.propNode61, Decl(ast.ts, 63, 50)) + +export interface Node62 { kind: SyntaxKind.Node62; propNode62: number; } +>Node62 : Symbol(Node62, Decl(ast.ts, 63, 72)) +>kind : Symbol(Node62.kind, Decl(ast.ts, 64, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node62 : Symbol(SyntaxKind.Node62, Decl(ast.ts, 0, 510)) +>propNode62 : Symbol(Node62.propNode62, Decl(ast.ts, 64, 50)) + +export interface Node63 { kind: SyntaxKind.Node63; propNode63: number; } +>Node63 : Symbol(Node63, Decl(ast.ts, 64, 72)) +>kind : Symbol(Node63.kind, Decl(ast.ts, 65, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node63 : Symbol(SyntaxKind.Node63, Decl(ast.ts, 0, 518)) +>propNode63 : Symbol(Node63.propNode63, Decl(ast.ts, 65, 50)) + +export interface Node64 { kind: SyntaxKind.Node64; propNode64: number; } +>Node64 : Symbol(Node64, Decl(ast.ts, 65, 72)) +>kind : Symbol(Node64.kind, Decl(ast.ts, 66, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node64 : Symbol(SyntaxKind.Node64, Decl(ast.ts, 0, 526)) +>propNode64 : Symbol(Node64.propNode64, Decl(ast.ts, 66, 50)) + +export interface Node65 { kind: SyntaxKind.Node65; propNode65: number; } +>Node65 : Symbol(Node65, Decl(ast.ts, 66, 72)) +>kind : Symbol(Node65.kind, Decl(ast.ts, 67, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node65 : Symbol(SyntaxKind.Node65, Decl(ast.ts, 0, 534)) +>propNode65 : Symbol(Node65.propNode65, Decl(ast.ts, 67, 50)) + +export interface Node66 { kind: SyntaxKind.Node66; propNode66: number; } +>Node66 : Symbol(Node66, Decl(ast.ts, 67, 72)) +>kind : Symbol(Node66.kind, Decl(ast.ts, 68, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node66 : Symbol(SyntaxKind.Node66, Decl(ast.ts, 0, 542)) +>propNode66 : Symbol(Node66.propNode66, Decl(ast.ts, 68, 50)) + +export interface Node67 { kind: SyntaxKind.Node67; propNode67: number; } +>Node67 : Symbol(Node67, Decl(ast.ts, 68, 72)) +>kind : Symbol(Node67.kind, Decl(ast.ts, 69, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node67 : Symbol(SyntaxKind.Node67, Decl(ast.ts, 0, 550)) +>propNode67 : Symbol(Node67.propNode67, Decl(ast.ts, 69, 50)) + +export interface Node68 { kind: SyntaxKind.Node68; propNode68: number; } +>Node68 : Symbol(Node68, Decl(ast.ts, 69, 72)) +>kind : Symbol(Node68.kind, Decl(ast.ts, 70, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node68 : Symbol(SyntaxKind.Node68, Decl(ast.ts, 0, 558)) +>propNode68 : Symbol(Node68.propNode68, Decl(ast.ts, 70, 50)) + +export interface Node69 { kind: SyntaxKind.Node69; propNode69: number; } +>Node69 : Symbol(Node69, Decl(ast.ts, 70, 72)) +>kind : Symbol(Node69.kind, Decl(ast.ts, 71, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node69 : Symbol(SyntaxKind.Node69, Decl(ast.ts, 0, 566)) +>propNode69 : Symbol(Node69.propNode69, Decl(ast.ts, 71, 50)) + +export interface Node70 { kind: SyntaxKind.Node70; propNode70: number; } +>Node70 : Symbol(Node70, Decl(ast.ts, 71, 72)) +>kind : Symbol(Node70.kind, Decl(ast.ts, 72, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node70 : Symbol(SyntaxKind.Node70, Decl(ast.ts, 0, 574)) +>propNode70 : Symbol(Node70.propNode70, Decl(ast.ts, 72, 50)) + +export interface Node71 { kind: SyntaxKind.Node71; propNode71: number; } +>Node71 : Symbol(Node71, Decl(ast.ts, 72, 72)) +>kind : Symbol(Node71.kind, Decl(ast.ts, 73, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node71 : Symbol(SyntaxKind.Node71, Decl(ast.ts, 0, 582)) +>propNode71 : Symbol(Node71.propNode71, Decl(ast.ts, 73, 50)) + +export interface Node72 { kind: SyntaxKind.Node72; propNode72: number; } +>Node72 : Symbol(Node72, Decl(ast.ts, 73, 72)) +>kind : Symbol(Node72.kind, Decl(ast.ts, 74, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node72 : Symbol(SyntaxKind.Node72, Decl(ast.ts, 0, 590)) +>propNode72 : Symbol(Node72.propNode72, Decl(ast.ts, 74, 50)) + +export interface Node73 { kind: SyntaxKind.Node73; propNode73: number; } +>Node73 : Symbol(Node73, Decl(ast.ts, 74, 72)) +>kind : Symbol(Node73.kind, Decl(ast.ts, 75, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node73 : Symbol(SyntaxKind.Node73, Decl(ast.ts, 0, 598)) +>propNode73 : Symbol(Node73.propNode73, Decl(ast.ts, 75, 50)) + +export interface Node74 { kind: SyntaxKind.Node74; propNode74: number; } +>Node74 : Symbol(Node74, Decl(ast.ts, 75, 72)) +>kind : Symbol(Node74.kind, Decl(ast.ts, 76, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node74 : Symbol(SyntaxKind.Node74, Decl(ast.ts, 0, 606)) +>propNode74 : Symbol(Node74.propNode74, Decl(ast.ts, 76, 50)) + +export interface Node75 { kind: SyntaxKind.Node75; propNode75: number; } +>Node75 : Symbol(Node75, Decl(ast.ts, 76, 72)) +>kind : Symbol(Node75.kind, Decl(ast.ts, 77, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node75 : Symbol(SyntaxKind.Node75, Decl(ast.ts, 0, 614)) +>propNode75 : Symbol(Node75.propNode75, Decl(ast.ts, 77, 50)) + +export interface Node76 { kind: SyntaxKind.Node76; propNode76: number; } +>Node76 : Symbol(Node76, Decl(ast.ts, 77, 72)) +>kind : Symbol(Node76.kind, Decl(ast.ts, 78, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node76 : Symbol(SyntaxKind.Node76, Decl(ast.ts, 0, 622)) +>propNode76 : Symbol(Node76.propNode76, Decl(ast.ts, 78, 50)) + +export interface Node77 { kind: SyntaxKind.Node77; propNode77: number; } +>Node77 : Symbol(Node77, Decl(ast.ts, 78, 72)) +>kind : Symbol(Node77.kind, Decl(ast.ts, 79, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node77 : Symbol(SyntaxKind.Node77, Decl(ast.ts, 0, 630)) +>propNode77 : Symbol(Node77.propNode77, Decl(ast.ts, 79, 50)) + +export interface Node78 { kind: SyntaxKind.Node78; propNode78: number; } +>Node78 : Symbol(Node78, Decl(ast.ts, 79, 72)) +>kind : Symbol(Node78.kind, Decl(ast.ts, 80, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node78 : Symbol(SyntaxKind.Node78, Decl(ast.ts, 0, 638)) +>propNode78 : Symbol(Node78.propNode78, Decl(ast.ts, 80, 50)) + +export interface Node79 { kind: SyntaxKind.Node79; propNode79: number; } +>Node79 : Symbol(Node79, Decl(ast.ts, 80, 72)) +>kind : Symbol(Node79.kind, Decl(ast.ts, 81, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node79 : Symbol(SyntaxKind.Node79, Decl(ast.ts, 0, 646)) +>propNode79 : Symbol(Node79.propNode79, Decl(ast.ts, 81, 50)) + +export interface Node80 { kind: SyntaxKind.Node80; propNode80: number; } +>Node80 : Symbol(Node80, Decl(ast.ts, 81, 72)) +>kind : Symbol(Node80.kind, Decl(ast.ts, 82, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node80 : Symbol(SyntaxKind.Node80, Decl(ast.ts, 0, 654)) +>propNode80 : Symbol(Node80.propNode80, Decl(ast.ts, 82, 50)) + +export interface Node81 { kind: SyntaxKind.Node81; propNode81: number; } +>Node81 : Symbol(Node81, Decl(ast.ts, 82, 72)) +>kind : Symbol(Node81.kind, Decl(ast.ts, 83, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node81 : Symbol(SyntaxKind.Node81, Decl(ast.ts, 0, 662)) +>propNode81 : Symbol(Node81.propNode81, Decl(ast.ts, 83, 50)) + +export interface Node82 { kind: SyntaxKind.Node82; propNode82: number; } +>Node82 : Symbol(Node82, Decl(ast.ts, 83, 72)) +>kind : Symbol(Node82.kind, Decl(ast.ts, 84, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node82 : Symbol(SyntaxKind.Node82, Decl(ast.ts, 0, 670)) +>propNode82 : Symbol(Node82.propNode82, Decl(ast.ts, 84, 50)) + +export interface Node83 { kind: SyntaxKind.Node83; propNode83: number; } +>Node83 : Symbol(Node83, Decl(ast.ts, 84, 72)) +>kind : Symbol(Node83.kind, Decl(ast.ts, 85, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node83 : Symbol(SyntaxKind.Node83, Decl(ast.ts, 0, 678)) +>propNode83 : Symbol(Node83.propNode83, Decl(ast.ts, 85, 50)) + +export interface Node84 { kind: SyntaxKind.Node84; propNode84: number; } +>Node84 : Symbol(Node84, Decl(ast.ts, 85, 72)) +>kind : Symbol(Node84.kind, Decl(ast.ts, 86, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node84 : Symbol(SyntaxKind.Node84, Decl(ast.ts, 0, 686)) +>propNode84 : Symbol(Node84.propNode84, Decl(ast.ts, 86, 50)) + +export interface Node85 { kind: SyntaxKind.Node85; propNode85: number; } +>Node85 : Symbol(Node85, Decl(ast.ts, 86, 72)) +>kind : Symbol(Node85.kind, Decl(ast.ts, 87, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node85 : Symbol(SyntaxKind.Node85, Decl(ast.ts, 0, 694)) +>propNode85 : Symbol(Node85.propNode85, Decl(ast.ts, 87, 50)) + +export interface Node86 { kind: SyntaxKind.Node86; propNode86: number; } +>Node86 : Symbol(Node86, Decl(ast.ts, 87, 72)) +>kind : Symbol(Node86.kind, Decl(ast.ts, 88, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node86 : Symbol(SyntaxKind.Node86, Decl(ast.ts, 0, 702)) +>propNode86 : Symbol(Node86.propNode86, Decl(ast.ts, 88, 50)) + +export interface Node87 { kind: SyntaxKind.Node87; propNode87: number; } +>Node87 : Symbol(Node87, Decl(ast.ts, 88, 72)) +>kind : Symbol(Node87.kind, Decl(ast.ts, 89, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node87 : Symbol(SyntaxKind.Node87, Decl(ast.ts, 0, 710)) +>propNode87 : Symbol(Node87.propNode87, Decl(ast.ts, 89, 50)) + +export interface Node88 { kind: SyntaxKind.Node88; propNode88: number; } +>Node88 : Symbol(Node88, Decl(ast.ts, 89, 72)) +>kind : Symbol(Node88.kind, Decl(ast.ts, 90, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node88 : Symbol(SyntaxKind.Node88, Decl(ast.ts, 0, 718)) +>propNode88 : Symbol(Node88.propNode88, Decl(ast.ts, 90, 50)) + +export interface Node89 { kind: SyntaxKind.Node89; propNode89: number; } +>Node89 : Symbol(Node89, Decl(ast.ts, 90, 72)) +>kind : Symbol(Node89.kind, Decl(ast.ts, 91, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node89 : Symbol(SyntaxKind.Node89, Decl(ast.ts, 0, 726)) +>propNode89 : Symbol(Node89.propNode89, Decl(ast.ts, 91, 50)) + +export interface Node90 { kind: SyntaxKind.Node90; propNode90: number; } +>Node90 : Symbol(Node90, Decl(ast.ts, 91, 72)) +>kind : Symbol(Node90.kind, Decl(ast.ts, 92, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node90 : Symbol(SyntaxKind.Node90, Decl(ast.ts, 0, 734)) +>propNode90 : Symbol(Node90.propNode90, Decl(ast.ts, 92, 50)) + +export interface Node91 { kind: SyntaxKind.Node91; propNode91: number; } +>Node91 : Symbol(Node91, Decl(ast.ts, 92, 72)) +>kind : Symbol(Node91.kind, Decl(ast.ts, 93, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node91 : Symbol(SyntaxKind.Node91, Decl(ast.ts, 0, 742)) +>propNode91 : Symbol(Node91.propNode91, Decl(ast.ts, 93, 50)) + +export interface Node92 { kind: SyntaxKind.Node92; propNode92: number; } +>Node92 : Symbol(Node92, Decl(ast.ts, 93, 72)) +>kind : Symbol(Node92.kind, Decl(ast.ts, 94, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node92 : Symbol(SyntaxKind.Node92, Decl(ast.ts, 0, 750)) +>propNode92 : Symbol(Node92.propNode92, Decl(ast.ts, 94, 50)) + +export interface Node93 { kind: SyntaxKind.Node93; propNode93: number; } +>Node93 : Symbol(Node93, Decl(ast.ts, 94, 72)) +>kind : Symbol(Node93.kind, Decl(ast.ts, 95, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node93 : Symbol(SyntaxKind.Node93, Decl(ast.ts, 0, 758)) +>propNode93 : Symbol(Node93.propNode93, Decl(ast.ts, 95, 50)) + +export interface Node94 { kind: SyntaxKind.Node94; propNode94: number; } +>Node94 : Symbol(Node94, Decl(ast.ts, 95, 72)) +>kind : Symbol(Node94.kind, Decl(ast.ts, 96, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node94 : Symbol(SyntaxKind.Node94, Decl(ast.ts, 0, 766)) +>propNode94 : Symbol(Node94.propNode94, Decl(ast.ts, 96, 50)) + +export interface Node95 { kind: SyntaxKind.Node95; propNode95: number; } +>Node95 : Symbol(Node95, Decl(ast.ts, 96, 72)) +>kind : Symbol(Node95.kind, Decl(ast.ts, 97, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node95 : Symbol(SyntaxKind.Node95, Decl(ast.ts, 0, 774)) +>propNode95 : Symbol(Node95.propNode95, Decl(ast.ts, 97, 50)) + +export interface Node96 { kind: SyntaxKind.Node96; propNode96: number; } +>Node96 : Symbol(Node96, Decl(ast.ts, 97, 72)) +>kind : Symbol(Node96.kind, Decl(ast.ts, 98, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node96 : Symbol(SyntaxKind.Node96, Decl(ast.ts, 0, 782)) +>propNode96 : Symbol(Node96.propNode96, Decl(ast.ts, 98, 50)) + +export interface Node97 { kind: SyntaxKind.Node97; propNode97: number; } +>Node97 : Symbol(Node97, Decl(ast.ts, 98, 72)) +>kind : Symbol(Node97.kind, Decl(ast.ts, 99, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node97 : Symbol(SyntaxKind.Node97, Decl(ast.ts, 0, 790)) +>propNode97 : Symbol(Node97.propNode97, Decl(ast.ts, 99, 50)) + +export interface Node98 { kind: SyntaxKind.Node98; propNode98: number; } +>Node98 : Symbol(Node98, Decl(ast.ts, 99, 72)) +>kind : Symbol(Node98.kind, Decl(ast.ts, 100, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node98 : Symbol(SyntaxKind.Node98, Decl(ast.ts, 0, 798)) +>propNode98 : Symbol(Node98.propNode98, Decl(ast.ts, 100, 50)) + +export interface Node99 { kind: SyntaxKind.Node99; propNode99: number; } +>Node99 : Symbol(Node99, Decl(ast.ts, 100, 72)) +>kind : Symbol(Node99.kind, Decl(ast.ts, 101, 25)) +>SyntaxKind : Symbol(SyntaxKind, Decl(ast.ts, 0, 0)) +>Node99 : Symbol(SyntaxKind.Node99, Decl(ast.ts, 0, 806)) +>propNode99 : Symbol(Node99.propNode99, Decl(ast.ts, 101, 50)) + +export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node34 | Node35 | Node36 | Node37 | Node38 | Node39 | Node40 | Node41 | Node42 | Node43 | Node44 | Node45 | Node46 | Node47 | Node48 | Node49 | Node50 | Node51 | Node52 | Node53 | Node54 | Node55 | Node56 | Node57 | Node58 | Node59 | Node60 | Node61 | Node62 | Node63 | Node64 | Node65 | Node66 | Node67 | Node68 | Node69 | Node70 | Node71 | Node72 | Node73 | Node74 | Node75 | Node76 | Node77 | Node78 | Node79 | Node80 | Node81 | Node82 | Node83 | Node84 | Node85 | Node86 | Node87 | Node88 | Node89 | Node90 | Node91 | Node92 | Node93 | Node94 | Node95 | Node96 | Node97 | Node98 | Node99; +>Node : Symbol(Node, Decl(ast.ts, 101, 72)) +>Node0 : Symbol(Node0, Decl(ast.ts, 0, 815)) +>Node1 : Symbol(Node1, Decl(ast.ts, 2, 69)) +>Node2 : Symbol(Node2, Decl(ast.ts, 3, 69)) +>Node3 : Symbol(Node3, Decl(ast.ts, 4, 69)) +>Node4 : Symbol(Node4, Decl(ast.ts, 5, 69)) +>Node5 : Symbol(Node5, Decl(ast.ts, 6, 69)) +>Node6 : Symbol(Node6, Decl(ast.ts, 7, 69)) +>Node7 : Symbol(Node7, Decl(ast.ts, 8, 69)) +>Node8 : Symbol(Node8, Decl(ast.ts, 9, 69)) +>Node9 : Symbol(Node9, Decl(ast.ts, 10, 69)) +>Node10 : Symbol(Node10, Decl(ast.ts, 11, 69)) +>Node11 : Symbol(Node11, Decl(ast.ts, 12, 72)) +>Node12 : Symbol(Node12, Decl(ast.ts, 13, 72)) +>Node13 : Symbol(Node13, Decl(ast.ts, 14, 72)) +>Node14 : Symbol(Node14, Decl(ast.ts, 15, 72)) +>Node15 : Symbol(Node15, Decl(ast.ts, 16, 72)) +>Node16 : Symbol(Node16, Decl(ast.ts, 17, 72)) +>Node17 : Symbol(Node17, Decl(ast.ts, 18, 72)) +>Node18 : Symbol(Node18, Decl(ast.ts, 19, 72)) +>Node19 : Symbol(Node19, Decl(ast.ts, 20, 72)) +>Node20 : Symbol(Node20, Decl(ast.ts, 21, 72)) +>Node21 : Symbol(Node21, Decl(ast.ts, 22, 72)) +>Node22 : Symbol(Node22, Decl(ast.ts, 23, 72)) +>Node23 : Symbol(Node23, Decl(ast.ts, 24, 72)) +>Node24 : Symbol(Node24, Decl(ast.ts, 25, 72)) +>Node25 : Symbol(Node25, Decl(ast.ts, 26, 72)) +>Node26 : Symbol(Node26, Decl(ast.ts, 27, 72)) +>Node27 : Symbol(Node27, Decl(ast.ts, 28, 72)) +>Node28 : Symbol(Node28, Decl(ast.ts, 29, 72)) +>Node29 : Symbol(Node29, Decl(ast.ts, 30, 72)) +>Node30 : Symbol(Node30, Decl(ast.ts, 31, 72)) +>Node31 : Symbol(Node31, Decl(ast.ts, 32, 72)) +>Node32 : Symbol(Node32, Decl(ast.ts, 33, 72)) +>Node33 : Symbol(Node33, Decl(ast.ts, 34, 72)) +>Node34 : Symbol(Node34, Decl(ast.ts, 35, 72)) +>Node35 : Symbol(Node35, Decl(ast.ts, 36, 72)) +>Node36 : Symbol(Node36, Decl(ast.ts, 37, 72)) +>Node37 : Symbol(Node37, Decl(ast.ts, 38, 72)) +>Node38 : Symbol(Node38, Decl(ast.ts, 39, 72)) +>Node39 : Symbol(Node39, Decl(ast.ts, 40, 72)) +>Node40 : Symbol(Node40, Decl(ast.ts, 41, 72)) +>Node41 : Symbol(Node41, Decl(ast.ts, 42, 72)) +>Node42 : Symbol(Node42, Decl(ast.ts, 43, 72)) +>Node43 : Symbol(Node43, Decl(ast.ts, 44, 72)) +>Node44 : Symbol(Node44, Decl(ast.ts, 45, 72)) +>Node45 : Symbol(Node45, Decl(ast.ts, 46, 72)) +>Node46 : Symbol(Node46, Decl(ast.ts, 47, 72)) +>Node47 : Symbol(Node47, Decl(ast.ts, 48, 72)) +>Node48 : Symbol(Node48, Decl(ast.ts, 49, 72)) +>Node49 : Symbol(Node49, Decl(ast.ts, 50, 72)) +>Node50 : Symbol(Node50, Decl(ast.ts, 51, 72)) +>Node51 : Symbol(Node51, Decl(ast.ts, 52, 72)) +>Node52 : Symbol(Node52, Decl(ast.ts, 53, 72)) +>Node53 : Symbol(Node53, Decl(ast.ts, 54, 72)) +>Node54 : Symbol(Node54, Decl(ast.ts, 55, 72)) +>Node55 : Symbol(Node55, Decl(ast.ts, 56, 72)) +>Node56 : Symbol(Node56, Decl(ast.ts, 57, 72)) +>Node57 : Symbol(Node57, Decl(ast.ts, 58, 72)) +>Node58 : Symbol(Node58, Decl(ast.ts, 59, 72)) +>Node59 : Symbol(Node59, Decl(ast.ts, 60, 72)) +>Node60 : Symbol(Node60, Decl(ast.ts, 61, 72)) +>Node61 : Symbol(Node61, Decl(ast.ts, 62, 72)) +>Node62 : Symbol(Node62, Decl(ast.ts, 63, 72)) +>Node63 : Symbol(Node63, Decl(ast.ts, 64, 72)) +>Node64 : Symbol(Node64, Decl(ast.ts, 65, 72)) +>Node65 : Symbol(Node65, Decl(ast.ts, 66, 72)) +>Node66 : Symbol(Node66, Decl(ast.ts, 67, 72)) +>Node67 : Symbol(Node67, Decl(ast.ts, 68, 72)) +>Node68 : Symbol(Node68, Decl(ast.ts, 69, 72)) +>Node69 : Symbol(Node69, Decl(ast.ts, 70, 72)) +>Node70 : Symbol(Node70, Decl(ast.ts, 71, 72)) +>Node71 : Symbol(Node71, Decl(ast.ts, 72, 72)) +>Node72 : Symbol(Node72, Decl(ast.ts, 73, 72)) +>Node73 : Symbol(Node73, Decl(ast.ts, 74, 72)) +>Node74 : Symbol(Node74, Decl(ast.ts, 75, 72)) +>Node75 : Symbol(Node75, Decl(ast.ts, 76, 72)) +>Node76 : Symbol(Node76, Decl(ast.ts, 77, 72)) +>Node77 : Symbol(Node77, Decl(ast.ts, 78, 72)) +>Node78 : Symbol(Node78, Decl(ast.ts, 79, 72)) +>Node79 : Symbol(Node79, Decl(ast.ts, 80, 72)) +>Node80 : Symbol(Node80, Decl(ast.ts, 81, 72)) +>Node81 : Symbol(Node81, Decl(ast.ts, 82, 72)) +>Node82 : Symbol(Node82, Decl(ast.ts, 83, 72)) +>Node83 : Symbol(Node83, Decl(ast.ts, 84, 72)) +>Node84 : Symbol(Node84, Decl(ast.ts, 85, 72)) +>Node85 : Symbol(Node85, Decl(ast.ts, 86, 72)) +>Node86 : Symbol(Node86, Decl(ast.ts, 87, 72)) +>Node87 : Symbol(Node87, Decl(ast.ts, 88, 72)) +>Node88 : Symbol(Node88, Decl(ast.ts, 89, 72)) +>Node89 : Symbol(Node89, Decl(ast.ts, 90, 72)) +>Node90 : Symbol(Node90, Decl(ast.ts, 91, 72)) +>Node91 : Symbol(Node91, Decl(ast.ts, 92, 72)) +>Node92 : Symbol(Node92, Decl(ast.ts, 93, 72)) +>Node93 : Symbol(Node93, Decl(ast.ts, 94, 72)) +>Node94 : Symbol(Node94, Decl(ast.ts, 95, 72)) +>Node95 : Symbol(Node95, Decl(ast.ts, 96, 72)) +>Node96 : Symbol(Node96, Decl(ast.ts, 97, 72)) +>Node97 : Symbol(Node97, Decl(ast.ts, 98, 72)) +>Node98 : Symbol(Node98, Decl(ast.ts, 99, 72)) +>Node99 : Symbol(Node99, Decl(ast.ts, 100, 72)) + +=== index.ts === +import * as ast from "./ast"; +>ast : Symbol(ast, Decl(index.ts, 0, 6)) + +export const isNodeOfType = +>isNodeOfType : Symbol(isNodeOfType, Decl(index.ts, 2, 12)) + + (nodeType: NodeType) => +>NodeType : Symbol(NodeType, Decl(index.ts, 3, 3)) +>ast : Symbol(ast, Decl(index.ts, 0, 6)) +>SyntaxKind : Symbol(ast.SyntaxKind, Decl(ast.ts, 0, 0)) +>nodeType : Symbol(nodeType, Decl(index.ts, 3, 36)) +>NodeType : Symbol(NodeType, Decl(index.ts, 3, 3)) + + ( + node: ast.Node | null | undefined, +>node : Symbol(node, Decl(index.ts, 4, 3)) +>ast : Symbol(ast, Decl(index.ts, 0, 6)) +>Node : Symbol(ast.Node, Decl(ast.ts, 101, 72)) + + ): node is Extract => +>node : Symbol(node, Decl(index.ts, 4, 3)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>ast : Symbol(ast, Decl(index.ts, 0, 6)) +>Node : Symbol(ast.Node, Decl(ast.ts, 101, 72)) +>kind : Symbol(kind, Decl(index.ts, 6, 32)) +>NodeType : Symbol(NodeType, Decl(index.ts, 3, 3)) + + node?.kind === nodeType; +>node?.kind : Symbol(kind, Decl(ast.ts, 2, 24), Decl(ast.ts, 3, 24), Decl(ast.ts, 4, 24), Decl(ast.ts, 5, 24), Decl(ast.ts, 6, 24) ... and 95 more) +>node : Symbol(node, Decl(index.ts, 4, 3)) +>kind : Symbol(kind, Decl(ast.ts, 2, 24), Decl(ast.ts, 3, 24), Decl(ast.ts, 4, 24), Decl(ast.ts, 5, 24), Decl(ast.ts, 6, 24) ... and 95 more) +>nodeType : Symbol(nodeType, Decl(index.ts, 3, 36)) + + diff --git a/tests/baselines/reference/trackedSymbolsNoCrash.types b/tests/baselines/reference/trackedSymbolsNoCrash.types new file mode 100644 index 0000000000000..884db6780ba72 --- /dev/null +++ b/tests/baselines/reference/trackedSymbolsNoCrash.types @@ -0,0 +1,640 @@ +//// [tests/cases/compiler/trackedSymbolsNoCrash.ts] //// + +=== ast.ts === +export enum SyntaxKind { Node0, Node1, Node2, Node3, Node4, Node5, Node6, Node7, Node8, Node9, Node10, Node11, Node12, Node13, Node14, Node15, Node16, Node17, Node18, Node19, Node20, Node21, Node22, Node23, Node24, Node25, Node26, Node27, Node28, Node29, Node30, Node31, Node32, Node33, Node34, Node35, Node36, Node37, Node38, Node39, Node40, Node41, Node42, Node43, Node44, Node45, Node46, Node47, Node48, Node49, Node50, Node51, Node52, Node53, Node54, Node55, Node56, Node57, Node58, Node59, Node60, Node61, Node62, Node63, Node64, Node65, Node66, Node67, Node68, Node69, Node70, Node71, Node72, Node73, Node74, Node75, Node76, Node77, Node78, Node79, Node80, Node81, Node82, Node83, Node84, Node85, Node86, Node87, Node88, Node89, Node90, Node91, Node92, Node93, Node94, Node95, Node96, Node97, Node98, Node99 } +>SyntaxKind : SyntaxKind +>Node0 : SyntaxKind.Node0 +>Node1 : SyntaxKind.Node1 +>Node2 : SyntaxKind.Node2 +>Node3 : SyntaxKind.Node3 +>Node4 : SyntaxKind.Node4 +>Node5 : SyntaxKind.Node5 +>Node6 : SyntaxKind.Node6 +>Node7 : SyntaxKind.Node7 +>Node8 : SyntaxKind.Node8 +>Node9 : SyntaxKind.Node9 +>Node10 : SyntaxKind.Node10 +>Node11 : SyntaxKind.Node11 +>Node12 : SyntaxKind.Node12 +>Node13 : SyntaxKind.Node13 +>Node14 : SyntaxKind.Node14 +>Node15 : SyntaxKind.Node15 +>Node16 : SyntaxKind.Node16 +>Node17 : SyntaxKind.Node17 +>Node18 : SyntaxKind.Node18 +>Node19 : SyntaxKind.Node19 +>Node20 : SyntaxKind.Node20 +>Node21 : SyntaxKind.Node21 +>Node22 : SyntaxKind.Node22 +>Node23 : SyntaxKind.Node23 +>Node24 : SyntaxKind.Node24 +>Node25 : SyntaxKind.Node25 +>Node26 : SyntaxKind.Node26 +>Node27 : SyntaxKind.Node27 +>Node28 : SyntaxKind.Node28 +>Node29 : SyntaxKind.Node29 +>Node30 : SyntaxKind.Node30 +>Node31 : SyntaxKind.Node31 +>Node32 : SyntaxKind.Node32 +>Node33 : SyntaxKind.Node33 +>Node34 : SyntaxKind.Node34 +>Node35 : SyntaxKind.Node35 +>Node36 : SyntaxKind.Node36 +>Node37 : SyntaxKind.Node37 +>Node38 : SyntaxKind.Node38 +>Node39 : SyntaxKind.Node39 +>Node40 : SyntaxKind.Node40 +>Node41 : SyntaxKind.Node41 +>Node42 : SyntaxKind.Node42 +>Node43 : SyntaxKind.Node43 +>Node44 : SyntaxKind.Node44 +>Node45 : SyntaxKind.Node45 +>Node46 : SyntaxKind.Node46 +>Node47 : SyntaxKind.Node47 +>Node48 : SyntaxKind.Node48 +>Node49 : SyntaxKind.Node49 +>Node50 : SyntaxKind.Node50 +>Node51 : SyntaxKind.Node51 +>Node52 : SyntaxKind.Node52 +>Node53 : SyntaxKind.Node53 +>Node54 : SyntaxKind.Node54 +>Node55 : SyntaxKind.Node55 +>Node56 : SyntaxKind.Node56 +>Node57 : SyntaxKind.Node57 +>Node58 : SyntaxKind.Node58 +>Node59 : SyntaxKind.Node59 +>Node60 : SyntaxKind.Node60 +>Node61 : SyntaxKind.Node61 +>Node62 : SyntaxKind.Node62 +>Node63 : SyntaxKind.Node63 +>Node64 : SyntaxKind.Node64 +>Node65 : SyntaxKind.Node65 +>Node66 : SyntaxKind.Node66 +>Node67 : SyntaxKind.Node67 +>Node68 : SyntaxKind.Node68 +>Node69 : SyntaxKind.Node69 +>Node70 : SyntaxKind.Node70 +>Node71 : SyntaxKind.Node71 +>Node72 : SyntaxKind.Node72 +>Node73 : SyntaxKind.Node73 +>Node74 : SyntaxKind.Node74 +>Node75 : SyntaxKind.Node75 +>Node76 : SyntaxKind.Node76 +>Node77 : SyntaxKind.Node77 +>Node78 : SyntaxKind.Node78 +>Node79 : SyntaxKind.Node79 +>Node80 : SyntaxKind.Node80 +>Node81 : SyntaxKind.Node81 +>Node82 : SyntaxKind.Node82 +>Node83 : SyntaxKind.Node83 +>Node84 : SyntaxKind.Node84 +>Node85 : SyntaxKind.Node85 +>Node86 : SyntaxKind.Node86 +>Node87 : SyntaxKind.Node87 +>Node88 : SyntaxKind.Node88 +>Node89 : SyntaxKind.Node89 +>Node90 : SyntaxKind.Node90 +>Node91 : SyntaxKind.Node91 +>Node92 : SyntaxKind.Node92 +>Node93 : SyntaxKind.Node93 +>Node94 : SyntaxKind.Node94 +>Node95 : SyntaxKind.Node95 +>Node96 : SyntaxKind.Node96 +>Node97 : SyntaxKind.Node97 +>Node98 : SyntaxKind.Node98 +>Node99 : SyntaxKind.Node99 + +export interface Node0 { kind: SyntaxKind.Node0; propNode0: number; } +>kind : SyntaxKind.Node0 +>SyntaxKind : any +>propNode0 : number + +export interface Node1 { kind: SyntaxKind.Node1; propNode1: number; } +>kind : SyntaxKind.Node1 +>SyntaxKind : any +>propNode1 : number + +export interface Node2 { kind: SyntaxKind.Node2; propNode2: number; } +>kind : SyntaxKind.Node2 +>SyntaxKind : any +>propNode2 : number + +export interface Node3 { kind: SyntaxKind.Node3; propNode3: number; } +>kind : SyntaxKind.Node3 +>SyntaxKind : any +>propNode3 : number + +export interface Node4 { kind: SyntaxKind.Node4; propNode4: number; } +>kind : SyntaxKind.Node4 +>SyntaxKind : any +>propNode4 : number + +export interface Node5 { kind: SyntaxKind.Node5; propNode5: number; } +>kind : SyntaxKind.Node5 +>SyntaxKind : any +>propNode5 : number + +export interface Node6 { kind: SyntaxKind.Node6; propNode6: number; } +>kind : SyntaxKind.Node6 +>SyntaxKind : any +>propNode6 : number + +export interface Node7 { kind: SyntaxKind.Node7; propNode7: number; } +>kind : SyntaxKind.Node7 +>SyntaxKind : any +>propNode7 : number + +export interface Node8 { kind: SyntaxKind.Node8; propNode8: number; } +>kind : SyntaxKind.Node8 +>SyntaxKind : any +>propNode8 : number + +export interface Node9 { kind: SyntaxKind.Node9; propNode9: number; } +>kind : SyntaxKind.Node9 +>SyntaxKind : any +>propNode9 : number + +export interface Node10 { kind: SyntaxKind.Node10; propNode10: number; } +>kind : SyntaxKind.Node10 +>SyntaxKind : any +>propNode10 : number + +export interface Node11 { kind: SyntaxKind.Node11; propNode11: number; } +>kind : SyntaxKind.Node11 +>SyntaxKind : any +>propNode11 : number + +export interface Node12 { kind: SyntaxKind.Node12; propNode12: number; } +>kind : SyntaxKind.Node12 +>SyntaxKind : any +>propNode12 : number + +export interface Node13 { kind: SyntaxKind.Node13; propNode13: number; } +>kind : SyntaxKind.Node13 +>SyntaxKind : any +>propNode13 : number + +export interface Node14 { kind: SyntaxKind.Node14; propNode14: number; } +>kind : SyntaxKind.Node14 +>SyntaxKind : any +>propNode14 : number + +export interface Node15 { kind: SyntaxKind.Node15; propNode15: number; } +>kind : SyntaxKind.Node15 +>SyntaxKind : any +>propNode15 : number + +export interface Node16 { kind: SyntaxKind.Node16; propNode16: number; } +>kind : SyntaxKind.Node16 +>SyntaxKind : any +>propNode16 : number + +export interface Node17 { kind: SyntaxKind.Node17; propNode17: number; } +>kind : SyntaxKind.Node17 +>SyntaxKind : any +>propNode17 : number + +export interface Node18 { kind: SyntaxKind.Node18; propNode18: number; } +>kind : SyntaxKind.Node18 +>SyntaxKind : any +>propNode18 : number + +export interface Node19 { kind: SyntaxKind.Node19; propNode19: number; } +>kind : SyntaxKind.Node19 +>SyntaxKind : any +>propNode19 : number + +export interface Node20 { kind: SyntaxKind.Node20; propNode20: number; } +>kind : SyntaxKind.Node20 +>SyntaxKind : any +>propNode20 : number + +export interface Node21 { kind: SyntaxKind.Node21; propNode21: number; } +>kind : SyntaxKind.Node21 +>SyntaxKind : any +>propNode21 : number + +export interface Node22 { kind: SyntaxKind.Node22; propNode22: number; } +>kind : SyntaxKind.Node22 +>SyntaxKind : any +>propNode22 : number + +export interface Node23 { kind: SyntaxKind.Node23; propNode23: number; } +>kind : SyntaxKind.Node23 +>SyntaxKind : any +>propNode23 : number + +export interface Node24 { kind: SyntaxKind.Node24; propNode24: number; } +>kind : SyntaxKind.Node24 +>SyntaxKind : any +>propNode24 : number + +export interface Node25 { kind: SyntaxKind.Node25; propNode25: number; } +>kind : SyntaxKind.Node25 +>SyntaxKind : any +>propNode25 : number + +export interface Node26 { kind: SyntaxKind.Node26; propNode26: number; } +>kind : SyntaxKind.Node26 +>SyntaxKind : any +>propNode26 : number + +export interface Node27 { kind: SyntaxKind.Node27; propNode27: number; } +>kind : SyntaxKind.Node27 +>SyntaxKind : any +>propNode27 : number + +export interface Node28 { kind: SyntaxKind.Node28; propNode28: number; } +>kind : SyntaxKind.Node28 +>SyntaxKind : any +>propNode28 : number + +export interface Node29 { kind: SyntaxKind.Node29; propNode29: number; } +>kind : SyntaxKind.Node29 +>SyntaxKind : any +>propNode29 : number + +export interface Node30 { kind: SyntaxKind.Node30; propNode30: number; } +>kind : SyntaxKind.Node30 +>SyntaxKind : any +>propNode30 : number + +export interface Node31 { kind: SyntaxKind.Node31; propNode31: number; } +>kind : SyntaxKind.Node31 +>SyntaxKind : any +>propNode31 : number + +export interface Node32 { kind: SyntaxKind.Node32; propNode32: number; } +>kind : SyntaxKind.Node32 +>SyntaxKind : any +>propNode32 : number + +export interface Node33 { kind: SyntaxKind.Node33; propNode33: number; } +>kind : SyntaxKind.Node33 +>SyntaxKind : any +>propNode33 : number + +export interface Node34 { kind: SyntaxKind.Node34; propNode34: number; } +>kind : SyntaxKind.Node34 +>SyntaxKind : any +>propNode34 : number + +export interface Node35 { kind: SyntaxKind.Node35; propNode35: number; } +>kind : SyntaxKind.Node35 +>SyntaxKind : any +>propNode35 : number + +export interface Node36 { kind: SyntaxKind.Node36; propNode36: number; } +>kind : SyntaxKind.Node36 +>SyntaxKind : any +>propNode36 : number + +export interface Node37 { kind: SyntaxKind.Node37; propNode37: number; } +>kind : SyntaxKind.Node37 +>SyntaxKind : any +>propNode37 : number + +export interface Node38 { kind: SyntaxKind.Node38; propNode38: number; } +>kind : SyntaxKind.Node38 +>SyntaxKind : any +>propNode38 : number + +export interface Node39 { kind: SyntaxKind.Node39; propNode39: number; } +>kind : SyntaxKind.Node39 +>SyntaxKind : any +>propNode39 : number + +export interface Node40 { kind: SyntaxKind.Node40; propNode40: number; } +>kind : SyntaxKind.Node40 +>SyntaxKind : any +>propNode40 : number + +export interface Node41 { kind: SyntaxKind.Node41; propNode41: number; } +>kind : SyntaxKind.Node41 +>SyntaxKind : any +>propNode41 : number + +export interface Node42 { kind: SyntaxKind.Node42; propNode42: number; } +>kind : SyntaxKind.Node42 +>SyntaxKind : any +>propNode42 : number + +export interface Node43 { kind: SyntaxKind.Node43; propNode43: number; } +>kind : SyntaxKind.Node43 +>SyntaxKind : any +>propNode43 : number + +export interface Node44 { kind: SyntaxKind.Node44; propNode44: number; } +>kind : SyntaxKind.Node44 +>SyntaxKind : any +>propNode44 : number + +export interface Node45 { kind: SyntaxKind.Node45; propNode45: number; } +>kind : SyntaxKind.Node45 +>SyntaxKind : any +>propNode45 : number + +export interface Node46 { kind: SyntaxKind.Node46; propNode46: number; } +>kind : SyntaxKind.Node46 +>SyntaxKind : any +>propNode46 : number + +export interface Node47 { kind: SyntaxKind.Node47; propNode47: number; } +>kind : SyntaxKind.Node47 +>SyntaxKind : any +>propNode47 : number + +export interface Node48 { kind: SyntaxKind.Node48; propNode48: number; } +>kind : SyntaxKind.Node48 +>SyntaxKind : any +>propNode48 : number + +export interface Node49 { kind: SyntaxKind.Node49; propNode49: number; } +>kind : SyntaxKind.Node49 +>SyntaxKind : any +>propNode49 : number + +export interface Node50 { kind: SyntaxKind.Node50; propNode50: number; } +>kind : SyntaxKind.Node50 +>SyntaxKind : any +>propNode50 : number + +export interface Node51 { kind: SyntaxKind.Node51; propNode51: number; } +>kind : SyntaxKind.Node51 +>SyntaxKind : any +>propNode51 : number + +export interface Node52 { kind: SyntaxKind.Node52; propNode52: number; } +>kind : SyntaxKind.Node52 +>SyntaxKind : any +>propNode52 : number + +export interface Node53 { kind: SyntaxKind.Node53; propNode53: number; } +>kind : SyntaxKind.Node53 +>SyntaxKind : any +>propNode53 : number + +export interface Node54 { kind: SyntaxKind.Node54; propNode54: number; } +>kind : SyntaxKind.Node54 +>SyntaxKind : any +>propNode54 : number + +export interface Node55 { kind: SyntaxKind.Node55; propNode55: number; } +>kind : SyntaxKind.Node55 +>SyntaxKind : any +>propNode55 : number + +export interface Node56 { kind: SyntaxKind.Node56; propNode56: number; } +>kind : SyntaxKind.Node56 +>SyntaxKind : any +>propNode56 : number + +export interface Node57 { kind: SyntaxKind.Node57; propNode57: number; } +>kind : SyntaxKind.Node57 +>SyntaxKind : any +>propNode57 : number + +export interface Node58 { kind: SyntaxKind.Node58; propNode58: number; } +>kind : SyntaxKind.Node58 +>SyntaxKind : any +>propNode58 : number + +export interface Node59 { kind: SyntaxKind.Node59; propNode59: number; } +>kind : SyntaxKind.Node59 +>SyntaxKind : any +>propNode59 : number + +export interface Node60 { kind: SyntaxKind.Node60; propNode60: number; } +>kind : SyntaxKind.Node60 +>SyntaxKind : any +>propNode60 : number + +export interface Node61 { kind: SyntaxKind.Node61; propNode61: number; } +>kind : SyntaxKind.Node61 +>SyntaxKind : any +>propNode61 : number + +export interface Node62 { kind: SyntaxKind.Node62; propNode62: number; } +>kind : SyntaxKind.Node62 +>SyntaxKind : any +>propNode62 : number + +export interface Node63 { kind: SyntaxKind.Node63; propNode63: number; } +>kind : SyntaxKind.Node63 +>SyntaxKind : any +>propNode63 : number + +export interface Node64 { kind: SyntaxKind.Node64; propNode64: number; } +>kind : SyntaxKind.Node64 +>SyntaxKind : any +>propNode64 : number + +export interface Node65 { kind: SyntaxKind.Node65; propNode65: number; } +>kind : SyntaxKind.Node65 +>SyntaxKind : any +>propNode65 : number + +export interface Node66 { kind: SyntaxKind.Node66; propNode66: number; } +>kind : SyntaxKind.Node66 +>SyntaxKind : any +>propNode66 : number + +export interface Node67 { kind: SyntaxKind.Node67; propNode67: number; } +>kind : SyntaxKind.Node67 +>SyntaxKind : any +>propNode67 : number + +export interface Node68 { kind: SyntaxKind.Node68; propNode68: number; } +>kind : SyntaxKind.Node68 +>SyntaxKind : any +>propNode68 : number + +export interface Node69 { kind: SyntaxKind.Node69; propNode69: number; } +>kind : SyntaxKind.Node69 +>SyntaxKind : any +>propNode69 : number + +export interface Node70 { kind: SyntaxKind.Node70; propNode70: number; } +>kind : SyntaxKind.Node70 +>SyntaxKind : any +>propNode70 : number + +export interface Node71 { kind: SyntaxKind.Node71; propNode71: number; } +>kind : SyntaxKind.Node71 +>SyntaxKind : any +>propNode71 : number + +export interface Node72 { kind: SyntaxKind.Node72; propNode72: number; } +>kind : SyntaxKind.Node72 +>SyntaxKind : any +>propNode72 : number + +export interface Node73 { kind: SyntaxKind.Node73; propNode73: number; } +>kind : SyntaxKind.Node73 +>SyntaxKind : any +>propNode73 : number + +export interface Node74 { kind: SyntaxKind.Node74; propNode74: number; } +>kind : SyntaxKind.Node74 +>SyntaxKind : any +>propNode74 : number + +export interface Node75 { kind: SyntaxKind.Node75; propNode75: number; } +>kind : SyntaxKind.Node75 +>SyntaxKind : any +>propNode75 : number + +export interface Node76 { kind: SyntaxKind.Node76; propNode76: number; } +>kind : SyntaxKind.Node76 +>SyntaxKind : any +>propNode76 : number + +export interface Node77 { kind: SyntaxKind.Node77; propNode77: number; } +>kind : SyntaxKind.Node77 +>SyntaxKind : any +>propNode77 : number + +export interface Node78 { kind: SyntaxKind.Node78; propNode78: number; } +>kind : SyntaxKind.Node78 +>SyntaxKind : any +>propNode78 : number + +export interface Node79 { kind: SyntaxKind.Node79; propNode79: number; } +>kind : SyntaxKind.Node79 +>SyntaxKind : any +>propNode79 : number + +export interface Node80 { kind: SyntaxKind.Node80; propNode80: number; } +>kind : SyntaxKind.Node80 +>SyntaxKind : any +>propNode80 : number + +export interface Node81 { kind: SyntaxKind.Node81; propNode81: number; } +>kind : SyntaxKind.Node81 +>SyntaxKind : any +>propNode81 : number + +export interface Node82 { kind: SyntaxKind.Node82; propNode82: number; } +>kind : SyntaxKind.Node82 +>SyntaxKind : any +>propNode82 : number + +export interface Node83 { kind: SyntaxKind.Node83; propNode83: number; } +>kind : SyntaxKind.Node83 +>SyntaxKind : any +>propNode83 : number + +export interface Node84 { kind: SyntaxKind.Node84; propNode84: number; } +>kind : SyntaxKind.Node84 +>SyntaxKind : any +>propNode84 : number + +export interface Node85 { kind: SyntaxKind.Node85; propNode85: number; } +>kind : SyntaxKind.Node85 +>SyntaxKind : any +>propNode85 : number + +export interface Node86 { kind: SyntaxKind.Node86; propNode86: number; } +>kind : SyntaxKind.Node86 +>SyntaxKind : any +>propNode86 : number + +export interface Node87 { kind: SyntaxKind.Node87; propNode87: number; } +>kind : SyntaxKind.Node87 +>SyntaxKind : any +>propNode87 : number + +export interface Node88 { kind: SyntaxKind.Node88; propNode88: number; } +>kind : SyntaxKind.Node88 +>SyntaxKind : any +>propNode88 : number + +export interface Node89 { kind: SyntaxKind.Node89; propNode89: number; } +>kind : SyntaxKind.Node89 +>SyntaxKind : any +>propNode89 : number + +export interface Node90 { kind: SyntaxKind.Node90; propNode90: number; } +>kind : SyntaxKind.Node90 +>SyntaxKind : any +>propNode90 : number + +export interface Node91 { kind: SyntaxKind.Node91; propNode91: number; } +>kind : SyntaxKind.Node91 +>SyntaxKind : any +>propNode91 : number + +export interface Node92 { kind: SyntaxKind.Node92; propNode92: number; } +>kind : SyntaxKind.Node92 +>SyntaxKind : any +>propNode92 : number + +export interface Node93 { kind: SyntaxKind.Node93; propNode93: number; } +>kind : SyntaxKind.Node93 +>SyntaxKind : any +>propNode93 : number + +export interface Node94 { kind: SyntaxKind.Node94; propNode94: number; } +>kind : SyntaxKind.Node94 +>SyntaxKind : any +>propNode94 : number + +export interface Node95 { kind: SyntaxKind.Node95; propNode95: number; } +>kind : SyntaxKind.Node95 +>SyntaxKind : any +>propNode95 : number + +export interface Node96 { kind: SyntaxKind.Node96; propNode96: number; } +>kind : SyntaxKind.Node96 +>SyntaxKind : any +>propNode96 : number + +export interface Node97 { kind: SyntaxKind.Node97; propNode97: number; } +>kind : SyntaxKind.Node97 +>SyntaxKind : any +>propNode97 : number + +export interface Node98 { kind: SyntaxKind.Node98; propNode98: number; } +>kind : SyntaxKind.Node98 +>SyntaxKind : any +>propNode98 : number + +export interface Node99 { kind: SyntaxKind.Node99; propNode99: number; } +>kind : SyntaxKind.Node99 +>SyntaxKind : any +>propNode99 : number + +export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node34 | Node35 | Node36 | Node37 | Node38 | Node39 | Node40 | Node41 | Node42 | Node43 | Node44 | Node45 | Node46 | Node47 | Node48 | Node49 | Node50 | Node51 | Node52 | Node53 | Node54 | Node55 | Node56 | Node57 | Node58 | Node59 | Node60 | Node61 | Node62 | Node63 | Node64 | Node65 | Node66 | Node67 | Node68 | Node69 | Node70 | Node71 | Node72 | Node73 | Node74 | Node75 | Node76 | Node77 | Node78 | Node79 | Node80 | Node81 | Node82 | Node83 | Node84 | Node85 | Node86 | Node87 | Node88 | Node89 | Node90 | Node91 | Node92 | Node93 | Node94 | Node95 | Node96 | Node97 | Node98 | Node99; +>Node : Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node34 | Node35 | Node36 | Node37 | Node38 | Node39 | Node40 | Node41 | Node42 | Node43 | Node44 | Node45 | Node46 | Node47 | Node48 | Node49 | Node50 | Node51 | Node52 | Node53 | Node54 | Node55 | Node56 | Node57 | Node58 | Node59 | Node60 | Node61 | Node62 | Node63 | Node64 | Node65 | Node66 | Node67 | Node68 | Node69 | Node70 | Node71 | Node72 | Node73 | Node74 | Node75 | Node76 | Node77 | Node78 | Node79 | Node80 | Node81 | Node82 | Node83 | Node84 | Node85 | Node86 | Node87 | Node88 | Node89 | Node90 | Node91 | Node92 | Node93 | Node94 | Node95 | Node96 | Node97 | Node98 | Node99 + +=== index.ts === +import * as ast from "./ast"; +>ast : typeof ast + +export const isNodeOfType = +>isNodeOfType : (nodeType: NodeType) => (node: ast.Node | null | undefined) => node is Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract + + (nodeType: NodeType) => +>(nodeType: NodeType) => ( node: ast.Node | null | undefined, ): node is Extract => node?.kind === nodeType : (nodeType: NodeType) => (node: ast.Node | null | undefined) => node is Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract +>ast : any +>nodeType : NodeType + + ( +>( node: ast.Node | null | undefined, ): node is Extract => node?.kind === nodeType : (node: ast.Node | null | undefined) => node is Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract | Extract + + node: ast.Node | null | undefined, +>node : ast.Node | null | undefined +>ast : any + + ): node is Extract => +>ast : any +>kind : NodeType + + node?.kind === nodeType; +>node?.kind === nodeType : boolean +>node?.kind : ast.SyntaxKind | undefined +>node : ast.Node | null | undefined +>kind : ast.SyntaxKind | undefined +>nodeType : NodeType + + diff --git a/tests/cases/compiler/accessorInferredReturnTypeErrorInReturnStatement.ts b/tests/cases/compiler/accessorInferredReturnTypeErrorInReturnStatement.ts new file mode 100644 index 0000000000000..1bc5ff1eac9c8 --- /dev/null +++ b/tests/cases/compiler/accessorInferredReturnTypeErrorInReturnStatement.ts @@ -0,0 +1,9 @@ +// @strict: true +// @declaration: true + +export var basePrototype = { + get primaryPath() { + var _this = this; + return _this.collection.schema.primaryPath; + }, +}; diff --git a/tests/cases/compiler/fakeInfinity1.ts b/tests/cases/compiler/fakeInfinity1.ts new file mode 100644 index 0000000000000..06fd705a6a248 --- /dev/null +++ b/tests/cases/compiler/fakeInfinity1.ts @@ -0,0 +1,25 @@ +// @strict: true +// @declaration: true + +// These are not actually the real infinity. +export type PositiveInfinity = 1e999; +export type NegativeInfinity = -1e999; + +export type TypeOfInfinity = typeof Infinity; +export type TypeOfNaN = typeof NaN; + +type A = 1e999; +type B = 1e9999; + +declare let a: A; +declare let b: B; + +a = b; +b = a; + +a = Infinity; +a = 1e999; +a = 1e9999; + +export type Oops = 123456789123456789123456789123456789123456789123456789; +export const oops = 123456789123456789123456789123456789123456789123456789; diff --git a/tests/cases/compiler/fakeInfinity2.ts b/tests/cases/compiler/fakeInfinity2.ts new file mode 100644 index 0000000000000..a2666a5be527a --- /dev/null +++ b/tests/cases/compiler/fakeInfinity2.ts @@ -0,0 +1,18 @@ +// @strict: true +// @declaration: true + +export enum Foo { + A = 1e999, + B = -1e999, +} + +namespace X { + type A = 1e999; + type B = 2e999; + + export function f(): A { + throw new Error() + } +} + +export const m = X.f(); diff --git a/tests/cases/compiler/fakeInfinity3.ts b/tests/cases/compiler/fakeInfinity3.ts new file mode 100644 index 0000000000000..536a48e477e0e --- /dev/null +++ b/tests/cases/compiler/fakeInfinity3.ts @@ -0,0 +1,20 @@ +// @strict: true +// @declaration: true + +export enum Foo { + A = 1e999, + B = -1e999, +} + +namespace X { + type A = 1e999; + type B = 2e999; + + export function f(): A { + throw new Error() + } +} + +export const m = X.f(); + +export const Infinity = "oops"; diff --git a/tests/cases/compiler/trackedSymbolsNoCrash.ts b/tests/cases/compiler/trackedSymbolsNoCrash.ts new file mode 100644 index 0000000000000..85a7e3552475a --- /dev/null +++ b/tests/cases/compiler/trackedSymbolsNoCrash.ts @@ -0,0 +1,119 @@ +// @strict: true +// @declaration: true + +// @filename: ast.ts +export enum SyntaxKind { Node0, Node1, Node2, Node3, Node4, Node5, Node6, Node7, Node8, Node9, Node10, Node11, Node12, Node13, Node14, Node15, Node16, Node17, Node18, Node19, Node20, Node21, Node22, Node23, Node24, Node25, Node26, Node27, Node28, Node29, Node30, Node31, Node32, Node33, Node34, Node35, Node36, Node37, Node38, Node39, Node40, Node41, Node42, Node43, Node44, Node45, Node46, Node47, Node48, Node49, Node50, Node51, Node52, Node53, Node54, Node55, Node56, Node57, Node58, Node59, Node60, Node61, Node62, Node63, Node64, Node65, Node66, Node67, Node68, Node69, Node70, Node71, Node72, Node73, Node74, Node75, Node76, Node77, Node78, Node79, Node80, Node81, Node82, Node83, Node84, Node85, Node86, Node87, Node88, Node89, Node90, Node91, Node92, Node93, Node94, Node95, Node96, Node97, Node98, Node99 } + +export interface Node0 { kind: SyntaxKind.Node0; propNode0: number; } +export interface Node1 { kind: SyntaxKind.Node1; propNode1: number; } +export interface Node2 { kind: SyntaxKind.Node2; propNode2: number; } +export interface Node3 { kind: SyntaxKind.Node3; propNode3: number; } +export interface Node4 { kind: SyntaxKind.Node4; propNode4: number; } +export interface Node5 { kind: SyntaxKind.Node5; propNode5: number; } +export interface Node6 { kind: SyntaxKind.Node6; propNode6: number; } +export interface Node7 { kind: SyntaxKind.Node7; propNode7: number; } +export interface Node8 { kind: SyntaxKind.Node8; propNode8: number; } +export interface Node9 { kind: SyntaxKind.Node9; propNode9: number; } +export interface Node10 { kind: SyntaxKind.Node10; propNode10: number; } +export interface Node11 { kind: SyntaxKind.Node11; propNode11: number; } +export interface Node12 { kind: SyntaxKind.Node12; propNode12: number; } +export interface Node13 { kind: SyntaxKind.Node13; propNode13: number; } +export interface Node14 { kind: SyntaxKind.Node14; propNode14: number; } +export interface Node15 { kind: SyntaxKind.Node15; propNode15: number; } +export interface Node16 { kind: SyntaxKind.Node16; propNode16: number; } +export interface Node17 { kind: SyntaxKind.Node17; propNode17: number; } +export interface Node18 { kind: SyntaxKind.Node18; propNode18: number; } +export interface Node19 { kind: SyntaxKind.Node19; propNode19: number; } +export interface Node20 { kind: SyntaxKind.Node20; propNode20: number; } +export interface Node21 { kind: SyntaxKind.Node21; propNode21: number; } +export interface Node22 { kind: SyntaxKind.Node22; propNode22: number; } +export interface Node23 { kind: SyntaxKind.Node23; propNode23: number; } +export interface Node24 { kind: SyntaxKind.Node24; propNode24: number; } +export interface Node25 { kind: SyntaxKind.Node25; propNode25: number; } +export interface Node26 { kind: SyntaxKind.Node26; propNode26: number; } +export interface Node27 { kind: SyntaxKind.Node27; propNode27: number; } +export interface Node28 { kind: SyntaxKind.Node28; propNode28: number; } +export interface Node29 { kind: SyntaxKind.Node29; propNode29: number; } +export interface Node30 { kind: SyntaxKind.Node30; propNode30: number; } +export interface Node31 { kind: SyntaxKind.Node31; propNode31: number; } +export interface Node32 { kind: SyntaxKind.Node32; propNode32: number; } +export interface Node33 { kind: SyntaxKind.Node33; propNode33: number; } +export interface Node34 { kind: SyntaxKind.Node34; propNode34: number; } +export interface Node35 { kind: SyntaxKind.Node35; propNode35: number; } +export interface Node36 { kind: SyntaxKind.Node36; propNode36: number; } +export interface Node37 { kind: SyntaxKind.Node37; propNode37: number; } +export interface Node38 { kind: SyntaxKind.Node38; propNode38: number; } +export interface Node39 { kind: SyntaxKind.Node39; propNode39: number; } +export interface Node40 { kind: SyntaxKind.Node40; propNode40: number; } +export interface Node41 { kind: SyntaxKind.Node41; propNode41: number; } +export interface Node42 { kind: SyntaxKind.Node42; propNode42: number; } +export interface Node43 { kind: SyntaxKind.Node43; propNode43: number; } +export interface Node44 { kind: SyntaxKind.Node44; propNode44: number; } +export interface Node45 { kind: SyntaxKind.Node45; propNode45: number; } +export interface Node46 { kind: SyntaxKind.Node46; propNode46: number; } +export interface Node47 { kind: SyntaxKind.Node47; propNode47: number; } +export interface Node48 { kind: SyntaxKind.Node48; propNode48: number; } +export interface Node49 { kind: SyntaxKind.Node49; propNode49: number; } +export interface Node50 { kind: SyntaxKind.Node50; propNode50: number; } +export interface Node51 { kind: SyntaxKind.Node51; propNode51: number; } +export interface Node52 { kind: SyntaxKind.Node52; propNode52: number; } +export interface Node53 { kind: SyntaxKind.Node53; propNode53: number; } +export interface Node54 { kind: SyntaxKind.Node54; propNode54: number; } +export interface Node55 { kind: SyntaxKind.Node55; propNode55: number; } +export interface Node56 { kind: SyntaxKind.Node56; propNode56: number; } +export interface Node57 { kind: SyntaxKind.Node57; propNode57: number; } +export interface Node58 { kind: SyntaxKind.Node58; propNode58: number; } +export interface Node59 { kind: SyntaxKind.Node59; propNode59: number; } +export interface Node60 { kind: SyntaxKind.Node60; propNode60: number; } +export interface Node61 { kind: SyntaxKind.Node61; propNode61: number; } +export interface Node62 { kind: SyntaxKind.Node62; propNode62: number; } +export interface Node63 { kind: SyntaxKind.Node63; propNode63: number; } +export interface Node64 { kind: SyntaxKind.Node64; propNode64: number; } +export interface Node65 { kind: SyntaxKind.Node65; propNode65: number; } +export interface Node66 { kind: SyntaxKind.Node66; propNode66: number; } +export interface Node67 { kind: SyntaxKind.Node67; propNode67: number; } +export interface Node68 { kind: SyntaxKind.Node68; propNode68: number; } +export interface Node69 { kind: SyntaxKind.Node69; propNode69: number; } +export interface Node70 { kind: SyntaxKind.Node70; propNode70: number; } +export interface Node71 { kind: SyntaxKind.Node71; propNode71: number; } +export interface Node72 { kind: SyntaxKind.Node72; propNode72: number; } +export interface Node73 { kind: SyntaxKind.Node73; propNode73: number; } +export interface Node74 { kind: SyntaxKind.Node74; propNode74: number; } +export interface Node75 { kind: SyntaxKind.Node75; propNode75: number; } +export interface Node76 { kind: SyntaxKind.Node76; propNode76: number; } +export interface Node77 { kind: SyntaxKind.Node77; propNode77: number; } +export interface Node78 { kind: SyntaxKind.Node78; propNode78: number; } +export interface Node79 { kind: SyntaxKind.Node79; propNode79: number; } +export interface Node80 { kind: SyntaxKind.Node80; propNode80: number; } +export interface Node81 { kind: SyntaxKind.Node81; propNode81: number; } +export interface Node82 { kind: SyntaxKind.Node82; propNode82: number; } +export interface Node83 { kind: SyntaxKind.Node83; propNode83: number; } +export interface Node84 { kind: SyntaxKind.Node84; propNode84: number; } +export interface Node85 { kind: SyntaxKind.Node85; propNode85: number; } +export interface Node86 { kind: SyntaxKind.Node86; propNode86: number; } +export interface Node87 { kind: SyntaxKind.Node87; propNode87: number; } +export interface Node88 { kind: SyntaxKind.Node88; propNode88: number; } +export interface Node89 { kind: SyntaxKind.Node89; propNode89: number; } +export interface Node90 { kind: SyntaxKind.Node90; propNode90: number; } +export interface Node91 { kind: SyntaxKind.Node91; propNode91: number; } +export interface Node92 { kind: SyntaxKind.Node92; propNode92: number; } +export interface Node93 { kind: SyntaxKind.Node93; propNode93: number; } +export interface Node94 { kind: SyntaxKind.Node94; propNode94: number; } +export interface Node95 { kind: SyntaxKind.Node95; propNode95: number; } +export interface Node96 { kind: SyntaxKind.Node96; propNode96: number; } +export interface Node97 { kind: SyntaxKind.Node97; propNode97: number; } +export interface Node98 { kind: SyntaxKind.Node98; propNode98: number; } +export interface Node99 { kind: SyntaxKind.Node99; propNode99: number; } + +export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node34 | Node35 | Node36 | Node37 | Node38 | Node39 | Node40 | Node41 | Node42 | Node43 | Node44 | Node45 | Node46 | Node47 | Node48 | Node49 | Node50 | Node51 | Node52 | Node53 | Node54 | Node55 | Node56 | Node57 | Node58 | Node59 | Node60 | Node61 | Node62 | Node63 | Node64 | Node65 | Node66 | Node67 | Node68 | Node69 | Node70 | Node71 | Node72 | Node73 | Node74 | Node75 | Node76 | Node77 | Node78 | Node79 | Node80 | Node81 | Node82 | Node83 | Node84 | Node85 | Node86 | Node87 | Node88 | Node89 | Node90 | Node91 | Node92 | Node93 | Node94 | Node95 | Node96 | Node97 | Node98 | Node99; + +// @filename: index.ts +import * as ast from "./ast"; + +export const isNodeOfType = + (nodeType: NodeType) => + ( + node: ast.Node | null | undefined, + ): node is Extract => + node?.kind === nodeType; + diff --git a/tests/cases/fourslash/jsDocFunctionTypeCompletionsNoCrash.ts b/tests/cases/fourslash/jsDocFunctionTypeCompletionsNoCrash.ts new file mode 100644 index 0000000000000..316cc027754d8 --- /dev/null +++ b/tests/cases/fourslash/jsDocFunctionTypeCompletionsNoCrash.ts @@ -0,0 +1,13 @@ +/// + +//// /** +//// * @returns {function/**/(): string} +//// */ +//// function updateCalendarEvent() { +//// return ""; +//// } + +verify.completions({ + marker: "", + exact: completion.globalTypes +});