From 3333e906ddce997003f8f1a001a56438f55d5c35 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 15 Nov 2023 15:51:47 -0800 Subject: [PATCH] Revert "Disallow numeric literals with negative numbers (#55268)" (#56422) --- src/compiler/checker.ts | 16 ++--- src/compiler/factory/nodeFactory.ts | 5 +- src/compiler/transformers/declarations.ts | 9 +-- src/compiler/transformers/generators.ts | 2 +- src/compiler/transformers/ts.ts | 4 +- .../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 +- tests/cases/compiler/fakeInfinity1.ts | 25 +++++++ tests/cases/compiler/fakeInfinity2.ts | 18 +++++ tests/cases/compiler/fakeInfinity3.ts | 20 ++++++ 22 files changed, 566 insertions(+), 31 deletions(-) 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/cases/compiler/fakeInfinity1.ts create mode 100644 tests/cases/compiler/fakeInfinity2.ts create mode 100644 tests/cases/compiler/fakeInfinity3.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 0e7a89111164d..d114e649a4ccf 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -8328,7 +8328,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); } @@ -39006,14 +39006,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({ @@ -47949,9 +47944,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/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/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/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";