more precise type facts for intersection

tests/baselines/reference/narrowingTypeof.js

@@ -0,0 +1,15 @@
+//// [narrowingTypeof.ts]
+type __String = (string & { __escapedIdentifier: void }) | (void & { __escapedIdentifier: void });
+
+declare const s: __String;
+declare let t: string | number | undefined;
+
+declare function assert(e: unknown): asserts e;
+
+assert(typeof s === "string");
+t = s;
+
+
+//// [narrowingTypeof.js]
+assert(typeof s === "string");
+t = s;

tests/baselines/reference/narrowingTypeof.symbols

@@ -0,0 +1,26 @@
+=== tests/cases/compiler/narrowingTypeof.ts ===
+type __String = (string & { __escapedIdentifier: void }) | (void & { __escapedIdentifier: void });
+>__String : Symbol(__String, Decl(narrowingTypeof.ts, 0, 0))
+>__escapedIdentifier : Symbol(__escapedIdentifier, Decl(narrowingTypeof.ts, 0, 27))
+>__escapedIdentifier : Symbol(__escapedIdentifier, Decl(narrowingTypeof.ts, 0, 68))
+
+declare const s: __String;
+>s : Symbol(s, Decl(narrowingTypeof.ts, 2, 13))
+>__String : Symbol(__String, Decl(narrowingTypeof.ts, 0, 0))
+
+declare let t: string | number | undefined;
+>t : Symbol(t, Decl(narrowingTypeof.ts, 3, 11))
+
+declare function assert(e: unknown): asserts e;
+>assert : Symbol(assert, Decl(narrowingTypeof.ts, 3, 43))
+>e : Symbol(e, Decl(narrowingTypeof.ts, 5, 24))
+>e : Symbol(e, Decl(narrowingTypeof.ts, 5, 24))
+
+assert(typeof s === "string");
+>assert : Symbol(assert, Decl(narrowingTypeof.ts, 3, 43))
+>s : Symbol(s, Decl(narrowingTypeof.ts, 2, 13))
+
+t = s;
+>t : Symbol(t, Decl(narrowingTypeof.ts, 3, 11))
+>s : Symbol(s, Decl(narrowingTypeof.ts, 2, 13))
+

tests/baselines/reference/narrowingTypeof.types

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/narrowingTypeof.ts ===
+type __String = (string & { __escapedIdentifier: void }) | (void & { __escapedIdentifier: void });
+>__String : __String
+>__escapedIdentifier : void
+>__escapedIdentifier : void
+
+declare const s: __String;
+>s : __String
+
+declare let t: string | number | undefined;
+>t : string | number
+
+declare function assert(e: unknown): asserts e;
+>assert : (e: unknown) => asserts e
+>e : unknown
+
+assert(typeof s === "string");
+>assert(typeof s === "string") : void
+>assert : (e: unknown) => asserts e
+>typeof s === "string" : boolean
+>typeof s : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>s : __String
+>"string" : "string"
+
+t = s;
+>t = s : string & { __escapedIdentifier: void; }
+>t : string | number
+>s : string & { __escapedIdentifier: void; }
+

tests/baselines/reference/narrowingTypeofFunction.js

@@ -0,0 +1,27 @@
+//// [narrowingTypeofFunction.ts]
+type Meta = { foo: string }
+interface F { (): string }
+
+const x = (a: (F & Meta) | string) => {
+    if (typeof a === "function") {
+        // ts.version >= 4.3.5: never -- unexpected
+        // ts.version <= 4.2.3: F & Meta -- expected
+        a;
+    }
+    else {
+        a;
+    }
+}
+
+//// [narrowingTypeofFunction.js]
+"use strict";
+var x = function (a) {
+    if (typeof a === "function") {
+        // ts.version >= 4.3.5: never -- unexpected
+        // ts.version <= 4.2.3: F & Meta -- expected
+        a;
+    }
+    else {
+        a;
+    }
+};

tests/baselines/reference/narrowingTypeofFunction.symbols

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/narrowingTypeofFunction.ts ===
+type Meta = { foo: string }
+>Meta : Symbol(Meta, Decl(narrowingTypeofFunction.ts, 0, 0))
+>foo : Symbol(foo, Decl(narrowingTypeofFunction.ts, 0, 13))
+
+interface F { (): string }
+>F : Symbol(F, Decl(narrowingTypeofFunction.ts, 0, 27))
+
+const x = (a: (F & Meta) | string) => {
+>x : Symbol(x, Decl(narrowingTypeofFunction.ts, 3, 5))
+>a : Symbol(a, Decl(narrowingTypeofFunction.ts, 3, 11))
+>F : Symbol(F, Decl(narrowingTypeofFunction.ts, 0, 27))
+>Meta : Symbol(Meta, Decl(narrowingTypeofFunction.ts, 0, 0))
+
+    if (typeof a === "function") {
+>a : Symbol(a, Decl(narrowingTypeofFunction.ts, 3, 11))
+
+        // ts.version >= 4.3.5: never -- unexpected
+        // ts.version <= 4.2.3: F & Meta -- expected
+        a;
+>a : Symbol(a, Decl(narrowingTypeofFunction.ts, 3, 11))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(narrowingTypeofFunction.ts, 3, 11))
+    }
+}

tests/baselines/reference/narrowingTypeofFunction.types

@@ -0,0 +1,28 @@
+=== tests/cases/compiler/narrowingTypeofFunction.ts ===
+type Meta = { foo: string }
+>Meta : Meta
+>foo : string
+
+interface F { (): string }
+
+const x = (a: (F & Meta) | string) => {
+>x : (a: (F & Meta) | string) => void
+>(a: (F & Meta) | string) => {    if (typeof a === "function") {        // ts.version >= 4.3.5: never -- unexpected        // ts.version <= 4.2.3: F & Meta -- expected        a;    }    else {        a;    }} : (a: (F & Meta) | string) => void
+>a : string | (F & Meta)
+
+    if (typeof a === "function") {
+>typeof a === "function" : boolean
+>typeof a : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>a : string | (F & Meta)
+>"function" : "function"
+
+        // ts.version >= 4.3.5: never -- unexpected
+        // ts.version <= 4.2.3: F & Meta -- expected
+        a;
+>a : F & Meta
+    }
+    else {
+        a;
+>a : string
+    }
+}

tests/cases/compiler/narrowingTypeof.ts

@@ -0,0 +1,10 @@
+
+type __String = (string & { __escapedIdentifier: void }) | (void & { __escapedIdentifier: void });
+
+declare const s: __String;
+declare let t: string | number | undefined;
+
+declare function assert(e: unknown): asserts e;
+
+assert(typeof s === "string");
+t = s;

tests/cases/compiler/narrowingTypeofFunction.ts

@@ -0,0 +1,15 @@
+// @strict: true
+
+type Meta = { foo: string }
+interface F { (): string }
+
+const x = (a: (F & Meta) | string) => {
+    if (typeof a === "function") {
+        // ts.version >= 4.3.5: never -- unexpected
+        // ts.version <= 4.2.3: F & Meta -- expected
+        a;
+    }
+    else {
+        a;
+    }
+}