Revert NaN and Infinity to number types when not used in type positions

Author: weswigham

src/compiler/checker.ts

@@ -16575,9 +16575,9 @@ namespace ts {
             addToSymbolTable(globals, builtinGlobals, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0);
 
             getSymbolLinks(undefinedSymbol).type = undefinedType;
-            getSymbolLinks(NaNSymbol).type = NaNLiteralType;
+            getSymbolLinks(NaNSymbol).type = numberType;
             getSymbolLinks(NaNSymbol).declaredType = NaNLiteralType;
-            getSymbolLinks(InfinitySymbol).type = InfinityLiteralType;
+            getSymbolLinks(InfinitySymbol).type = numberType;
             getSymbolLinks(InfinitySymbol).declaredType = InfinityLiteralType;
             getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments");
             getSymbolLinks(unknownSymbol).type = unknownType;

tests/baselines/reference/InfinityLiteralTypes.js

@@ -16,8 +16,8 @@ function invertInfinity(x: number): number {
 let a: PositiveInfinityMember;
 let b: NegativeInfinityMember;
 
-a = {member: Infinity};
-b = {member: -Infinity}
+a = {member: Infinity as Infinity};
+b = {member: -(<Infinity>Infinity)}
 
 let c: -Infinity = invertInfinity(a.member);
 let d: Infinity = invertInfinity(b.member);
@@ -27,6 +27,12 @@ declare function stillNumber(x: number): boolean;
 stillNumber(c);
 stillNumber(d);
 
+//Check that Infinity's declaration is still of type "number", while being "Infinity" when used as a type, so its usage is opt-in
+let y = Infinity;
+y = 42;
+let z = -Infinity;
+z = 42;
+
 /*declare function isInfinity(x: number): x is (Infinity | -Infinity) {
     return x !== x;
 }
@@ -52,6 +58,11 @@ var d = invertInfinity(b.member);
 var x = c + d;
 stillNumber(c);
 stillNumber(d);
+//Check that Infinity's declaration is still of type "number", while being "Infinity" when used as a type, so its usage is opt-in
+var y = Infinity;
+y = 42;
+var z = -Infinity;
+z = 42;
 /*declare function isInfinity(x: number): x is (Infinity | -Infinity) {
     return x !== x;
 }

tests/baselines/reference/InfinityLiteralTypes.symbols

@@ -40,15 +40,17 @@ let b: NegativeInfinityMember;
 >b : Symbol(b, Decl(InfinityLiteralTypes.ts, 15, 3))
 >NegativeInfinityMember : Symbol(NegativeInfinityMember, Decl(InfinityLiteralTypes.ts, 2, 1))
 
-a = {member: Infinity};
+a = {member: Infinity as Infinity};
 >a : Symbol(a, Decl(InfinityLiteralTypes.ts, 14, 3))
 >member : Symbol(member, Decl(InfinityLiteralTypes.ts, 17, 5))
 >Infinity : Symbol(Infinity)
+>Infinity : Symbol(Infinity)
 
-b = {member: -Infinity}
+b = {member: -(<Infinity>Infinity)}
 >b : Symbol(b, Decl(InfinityLiteralTypes.ts, 15, 3))
 >member : Symbol(member, Decl(InfinityLiteralTypes.ts, 18, 5))
 >Infinity : Symbol(Infinity)
+>Infinity : Symbol(Infinity)
 
 let c: -Infinity = invertInfinity(a.member);
 >c : Symbol(c, Decl(InfinityLiteralTypes.ts, 20, 3))
@@ -82,6 +84,21 @@ stillNumber(d);
 >stillNumber : Symbol(stillNumber, Decl(InfinityLiteralTypes.ts, 23, 14))
 >d : Symbol(d, Decl(InfinityLiteralTypes.ts, 21, 3))
 
+//Check that Infinity's declaration is still of type "number", while being "Infinity" when used as a type, so its usage is opt-in
+let y = Infinity;
+>y : Symbol(y, Decl(InfinityLiteralTypes.ts, 29, 3))
+>Infinity : Symbol(Infinity)
+
+y = 42;
+>y : Symbol(y, Decl(InfinityLiteralTypes.ts, 29, 3))
+
+let z = -Infinity;
+>z : Symbol(z, Decl(InfinityLiteralTypes.ts, 31, 3))
+>Infinity : Symbol(Infinity)
+
+z = 42;
+>z : Symbol(z, Decl(InfinityLiteralTypes.ts, 31, 3))
+
 /*declare function isInfinity(x: number): x is (Infinity | -Infinity) {
     return x !== x;
 }

tests/baselines/reference/InfinityLiteralTypes.types

@@ -41,20 +41,25 @@ let b: NegativeInfinityMember;
 >b : NegativeInfinityMember
 >NegativeInfinityMember : NegativeInfinityMember
 
-a = {member: Infinity};
->a = {member: Infinity} : { member: Infinity; }
+a = {member: Infinity as Infinity};
+>a = {member: Infinity as Infinity} : { member: Infinity; }
 >a : PositiveInfinityMember
->{member: Infinity} : { member: Infinity; }
+>{member: Infinity as Infinity} : { member: Infinity; }
 >member : Infinity
+>Infinity as Infinity : Infinity
+>Infinity : number
 >Infinity : Infinity
 
-b = {member: -Infinity}
->b = {member: -Infinity} : { member: -Infinity; }
+b = {member: -(<Infinity>Infinity)}
+>b = {member: -(<Infinity>Infinity)} : { member: -Infinity; }
 >b : NegativeInfinityMember
->{member: -Infinity} : { member: -Infinity; }
+>{member: -(<Infinity>Infinity)} : { member: -Infinity; }
 >member : -Infinity
->-Infinity : -Infinity
+>-(<Infinity>Infinity) : -Infinity
+>(<Infinity>Infinity) : Infinity
+><Infinity>Infinity : Infinity
 >Infinity : Infinity
+>Infinity : number
 
 let c: -Infinity = invertInfinity(a.member);
 >c : -Infinity
@@ -93,6 +98,26 @@ stillNumber(d);
 >stillNumber : (x: number) => boolean
 >d : Infinity
 
+//Check that Infinity's declaration is still of type "number", while being "Infinity" when used as a type, so its usage is opt-in
+let y = Infinity;
+>y : number
+>Infinity : number
+
+y = 42;
+>y = 42 : number
+>y : number
+>42 : number
+
+let z = -Infinity;
+>z : number
+>-Infinity : number
+>Infinity : number
+
+z = 42;
+>z = 42 : number
+>z : number
+>42 : number
+
 /*declare function isInfinity(x: number): x is (Infinity | -Infinity) {
     return x !== x;
 }

tests/baselines/reference/NaNLiteralTypes.js

@@ -4,11 +4,15 @@ interface NaNMember {
 }
 
 let x: NaNMember;
-x = {member: NaN}
+x = {member: NaN as NaN}
 
 declare function stillNumber(x: number): boolean;
 stillNumber(x.member);
 
+//Check that NaN's declaration is still of type "number", while being "NaN" when used as a type, so its usage is opt-in
+let y = NaN;
+y = 42;
+
 /*function isNaN(x: number): x is NaN {
     return x !== x;
 }
@@ -26,6 +30,9 @@ else {
 var x;
 x = { member: NaN };
 stillNumber(x.member);
+//Check that NaN's declaration is still of type "number", while being "NaN" when used as a type, so its usage is opt-in
+var y = NaN;
+y = 42;
 /*function isNaN(x: number): x is NaN {
     return x !== x;
 }

tests/baselines/reference/NaNLiteralTypes.symbols

@@ -11,21 +11,30 @@ let x: NaNMember;
 >x : Symbol(x, Decl(NaNLiteralTypes.ts, 4, 3))
 >NaNMember : Symbol(NaNMember, Decl(NaNLiteralTypes.ts, 0, 0))
 
-x = {member: NaN}
+x = {member: NaN as NaN}
 >x : Symbol(x, Decl(NaNLiteralTypes.ts, 4, 3))
 >member : Symbol(member, Decl(NaNLiteralTypes.ts, 5, 5))
 >NaN : Symbol(NaN)
+>NaN : Symbol(NaN)
 
 declare function stillNumber(x: number): boolean;
->stillNumber : Symbol(stillNumber, Decl(NaNLiteralTypes.ts, 5, 17))
+>stillNumber : Symbol(stillNumber, Decl(NaNLiteralTypes.ts, 5, 24))
 >x : Symbol(x, Decl(NaNLiteralTypes.ts, 7, 29))
 
 stillNumber(x.member);
->stillNumber : Symbol(stillNumber, Decl(NaNLiteralTypes.ts, 5, 17))
+>stillNumber : Symbol(stillNumber, Decl(NaNLiteralTypes.ts, 5, 24))
 >x.member : Symbol(NaNMember.member, Decl(NaNLiteralTypes.ts, 0, 21))
 >x : Symbol(x, Decl(NaNLiteralTypes.ts, 4, 3))
 >member : Symbol(NaNMember.member, Decl(NaNLiteralTypes.ts, 0, 21))
 
+//Check that NaN's declaration is still of type "number", while being "NaN" when used as a type, so its usage is opt-in
+let y = NaN;
+>y : Symbol(y, Decl(NaNLiteralTypes.ts, 11, 3))
+>NaN : Symbol(NaN)
+
+y = 42;
+>y : Symbol(y, Decl(NaNLiteralTypes.ts, 11, 3))
+
 /*function isNaN(x: number): x is NaN {
     return x !== x;
 }

tests/baselines/reference/NaNLiteralTypes.types

@@ -11,11 +11,13 @@ let x: NaNMember;
 >x : NaNMember
 >NaNMember : NaNMember
 
-x = {member: NaN}
->x = {member: NaN} : { member: NaN; }
+x = {member: NaN as NaN}
+>x = {member: NaN as NaN} : { member: NaN; }
 >x : NaNMember
->{member: NaN} : { member: NaN; }
+>{member: NaN as NaN} : { member: NaN; }
 >member : NaN
+>NaN as NaN : NaN
+>NaN : number
 >NaN : NaN
 
 declare function stillNumber(x: number): boolean;
@@ -29,6 +31,16 @@ stillNumber(x.member);
 >x : NaNMember
 >member : NaN
 
+//Check that NaN's declaration is still of type "number", while being "NaN" when used as a type, so its usage is opt-in
+let y = NaN;
+>y : number
+>NaN : number
+
+y = 42;
+>y = 42 : number
+>y : number
+>42 : number
+
 /*function isNaN(x: number): x is NaN {
     return x !== x;
 }

tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols

@@ -44,12 +44,12 @@ var t3 = file3.v3;
 >v3 : boolean
 
 var v4 = {a: true, b: NaN};  // Should shadow global v2 in this module
->v4 : { a: boolean; b: NaN; }
->{a: true, b: NaN} : { a: boolean; b: NaN; }
+>v4 : { a: boolean; b: number; }
+>{a: true, b: NaN} : { a: boolean; b: number; }
 >a : boolean
 >true : boolean
->b : NaN
->NaN : NaN
+>b : number
+>NaN : number
 
 === tests/cases/conformance/externalModules/file5.ts ===
 var x = v2; // Should be global v2 of type number again