Error when LHS of instanceof is Union of Primitives microsoft#18519

Author: charlespierce

src/compiler/checker.ts

@@ -17604,7 +17604,9 @@ namespace ts {
             // and the right operand to be of type Any, a subtype of the 'Function' interface type, or have a call or construct signature.
             // The result is always of the Boolean primitive type.
             // NOTE: do not raise error if leftType is unknown as related error was already reported
-            if (!isTypeAny(leftType) && isTypeAssignableToKind(leftType, TypeFlags.Primitive)) {
+            if (!isTypeAny(leftType) &&
+                (isTypeAssignableToKind(leftType, TypeFlags.Primitive) ||
+                 isTypeUnionOfPrimitives(leftType))) {
                 error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
             // NOTE: do not raise error if right is unknown as related error was already reported
@@ -17617,6 +17619,16 @@ namespace ts {
             return booleanType;
         }
 
+        function isTypeUnionOfPrimitives(source: Type) {
+            if (!(source.flags & TypeFlags.Union)) {
+                return false;
+            }
+
+            const unionTypes = (source as UnionType).types;
+
+            return every(unionTypes, subType => isTypeAssignableToKind(subType, TypeFlags.Primitive));
+        }
+
         function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
             if (leftType === silentNeverType || rightType === silentNeverType) {
                 return silentNeverType;

tests/baselines/reference/instanceofWithPrimitiveUnion.errors.txt

@@ -0,0 +1,12 @@
+tests/cases/compiler/instanceofWithPrimitiveUnion.ts(2,9): error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
+
+
+==== tests/cases/compiler/instanceofWithPrimitiveUnion.ts (1 errors) ====
+    function foo(x: number | string) {
+        if (x instanceof Object) {
+            ~
+!!! error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
+            x;
+        }
+    }
+    

tests/baselines/reference/instanceofWithPrimitiveUnion.js

@@ -0,0 +1,14 @@
+//// [instanceofWithPrimitiveUnion.ts]
+function foo(x: number | string) {
+    if (x instanceof Object) {
+        x;
+    }
+}
+
+
+//// [instanceofWithPrimitiveUnion.js]
+function foo(x) {
+    if (x instanceof Object) {
+        x;
+    }
+}

tests/baselines/reference/instanceofWithPrimitiveUnion.symbols

@@ -0,0 +1,14 @@
+=== tests/cases/compiler/instanceofWithPrimitiveUnion.ts ===
+function foo(x: number | string) {
+>foo : Symbol(foo, Decl(instanceofWithPrimitiveUnion.ts, 0, 0))
+>x : Symbol(x, Decl(instanceofWithPrimitiveUnion.ts, 0, 13))
+
+    if (x instanceof Object) {
+>x : Symbol(x, Decl(instanceofWithPrimitiveUnion.ts, 0, 13))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+        x;
+>x : Symbol(x, Decl(instanceofWithPrimitiveUnion.ts, 0, 13))
+    }
+}
+

tests/baselines/reference/instanceofWithPrimitiveUnion.types

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/instanceofWithPrimitiveUnion.ts ===
+function foo(x: number | string) {
+>foo : (x: string | number) => void
+>x : string | number
+
+    if (x instanceof Object) {
+>x instanceof Object : boolean
+>x : string | number
+>Object : ObjectConstructor
+
+        x;
+>x : string | number
+    }
+}
+

tests/cases/compiler/instanceofWithPrimitiveUnion.ts

@@ -0,0 +1,5 @@
+function foo(x: number | string) {
+    if (x instanceof Object) {
+        x;
+    }
+}