add type guard of constructor

src/compiler/checker.ts

@@ -14722,6 +14722,18 @@ namespace ts {
                         if (containsMatchingReferenceDiscriminant(reference, left) || containsMatchingReferenceDiscriminant(reference, right)) {
                             return declaredType;
                         }
+                        if (isPropertyAccessExpression(left) && idText(left.name) === "constructor") {
+                            return narrowTypeByConstructor(type, expr.right, operator, assumeTrue);
+                        }
+                        if (isPropertyAccessExpression(right) && idText(right.name) === "constructor") {
+                            return narrowTypeByConstructor(type, expr.left, operator, assumeTrue);
+                        }
+                        if (isElementAccessExpression(left) && isStringLiteralLike(left.argumentExpression) && left.argumentExpression.text === "constructor") {
+                            return narrowTypeByConstructor(type, expr.right, operator, assumeTrue);
+                        }
+                        if (isElementAccessExpression(right) && isStringLiteralLike(right.argumentExpression) && right.argumentExpression.text === "constructor") {
+                            return narrowTypeByConstructor(type, expr.left, operator, assumeTrue);
+                        }
                         break;
                     case SyntaxKind.InstanceOfKeyword:
                         return narrowTypeByInstanceof(type, expr, assumeTrue);
@@ -14741,7 +14753,7 @@ namespace ts {
                 if (type.flags & TypeFlags.Any) {
                     return type;
                 }
-                if (operator === SyntaxKind.ExclamationEqualsToken || operator === SyntaxKind.ExclamationEqualsEqualsToken) {
+                if (isNegatedEqualityToken(operator)) {
                     assumeTrue = !assumeTrue;
                 }
                 const valueType = getTypeOfExpression(value);
@@ -14771,6 +14783,26 @@ namespace ts {
                 return type;
             }
 
+            function narrowTypeByConstructor(type: Type, expr: Expression, operator: SyntaxKind, assumeTrue: boolean): Type {
+                if (!assumeTrue || isNegatedEqualityToken(operator)) return type;
+
+                const rightType = getTypeOfExpression(expr);
+                if (!isTypeSubtypeOf(rightType, globalFunctionType)) return type;
+
+                const prototypeProperty = getPropertyOfType(rightType, "prototype" as __String);
+                if (!prototypeProperty) return type;
+
+                const prototypePropertyType = getTypeOfSymbol(prototypeProperty);
+                const targetType = !isTypeAny(prototypePropertyType) ? prototypePropertyType : undefined;
+                if (!targetType || isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) return type;
+
+                return getNarrowedType(type, targetType, assumeTrue, isConstructedBy);
+
+                function isConstructedBy(source: Type, target: Type) {
+                    return source.flags & TypeFlags.Primitive ? areTypesComparable(source, target) : isTypeDerivedFrom(source, target);
+                }
+            }
+
             function narrowTypeByTypeof(type: Type, typeOfExpr: TypeOfExpression, operator: SyntaxKind, literal: LiteralExpression, assumeTrue: boolean): Type {
                 // We have '==', '!=', '====', or !==' operator with 'typeof xxx' and string literal operands
                 const target = getReferenceCandidate(typeOfExpr.expression);
@@ -14782,7 +14814,7 @@ namespace ts {
                     }
                     return type;
                 }
-                if (operator === SyntaxKind.ExclamationEqualsToken || operator === SyntaxKind.ExclamationEqualsEqualsToken) {
+                if (isNegatedEqualityToken(operator)) {
                     assumeTrue = !assumeTrue;
                 }
                 if (type.flags & TypeFlags.Any && literal.text === "function") {

src/compiler/utilities.ts

@@ -6685,6 +6685,11 @@ namespace ts {
         return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports;
     }
 
+    /** @internal */
+    export function isNegatedEqualityToken(kind: SyntaxKind): boolean {
+        return kind === SyntaxKind.ExclamationEqualsToken || kind === SyntaxKind.ExclamationEqualsEqualsToken;
+    }
+
     export interface ObjectAllocator {
         getNodeConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Node;
         getTokenConstructor(): new <TKind extends SyntaxKind>(kind: TKind, pos?: number, end?: number) => Token<TKind>;

tests/baselines/reference/typeGuardConstructor.errors.txt

@@ -0,0 +1,117 @@
+tests/cases/conformance/expressions/typeGuards/typeGuardConstructor.ts(45,11): error TS2339: Property 'p2' does not exist on type 'C1 | C2'.
+  Property 'p2' does not exist on type 'C1'.
+tests/cases/conformance/expressions/typeGuards/typeGuardConstructor.ts(49,11): error TS2339: Property 'p2' does not exist on type 'C1 | C2'.
+  Property 'p2' does not exist on type 'C1'.
+tests/cases/conformance/expressions/typeGuards/typeGuardConstructor.ts(52,11): error TS2339: Property 'p1' does not exist on type 'C1 | C2'.
+  Property 'p1' does not exist on type 'C2'.
+tests/cases/conformance/expressions/typeGuards/typeGuardConstructor.ts(63,11): error TS2339: Property 'p4' does not exist on type 'C1 | C2 | C3'.
+  Property 'p4' does not exist on type 'C1'.
+
+
+==== tests/cases/conformance/expressions/typeGuards/typeGuardConstructor.ts (4 errors) ====
+    class C1 {
+        p1: string;
+    }
+    class C2 {
+        p2: number;
+    }
+    class D1 extends C1 {
+        p3: number;
+    }
+    class C3 {
+        p4: number;
+    }
+    class D2 extends D1 {
+        p5: number
+    }
+
+    var a: C1;
+    if (a.constructor === D1) {
+        a.p3;
+    }
+    if (a.constructor == D1) {
+        a.p3;
+    }
+    if (D1 === a.constructor) {
+        a.p3;
+    }
+    if (a["constructor"] === D1) {
+        a.p3;
+    }
+    if (D1 === a["constructor"]) {
+        a.p3;
+    }
+
+    var b: C1;
+    if (b.constructor === D2) {
+        b.p3;
+        b.p5;
+    }
+
+    var ctor3: C1 | C2;
+    if (ctor3.constructor ===  C1) {
+        ctor3.p1; // C1
+    }
+    else {
+        ctor3.p2; // C2
+              ~~
+!!! error TS2339: Property 'p2' does not exist on type 'C1 | C2'.
+!!! error TS2339:   Property 'p2' does not exist on type 'C1'.
+    }
+
+    if (ctor3.constructor !==  C1) {
+        ctor3.p2; // C1
+              ~~
+!!! error TS2339: Property 'p2' does not exist on type 'C1 | C2'.
+!!! error TS2339:   Property 'p2' does not exist on type 'C1'.
+    }
+    else {
+        ctor3.p1; // C2
+              ~~
+!!! error TS2339: Property 'p1' does not exist on type 'C1 | C2'.
+!!! error TS2339:   Property 'p1' does not exist on type 'C2'.
+    }
+
+    var ctor4: C1 | C2 | C3;
+    if (ctor4.constructor ===  C1) {
+        ctor4.p1; // C1
+    }
+    else if (ctor4.constructor ===  C2) {
+        ctor4.p2; // C2
+    }
+    else {
+        ctor4.p4; // C3
+              ~~
+!!! error TS2339: Property 'p4' does not exist on type 'C1 | C2 | C3'.
+!!! error TS2339:   Property 'p4' does not exist on type 'C1'.
+    }
+
+    var x: number | "hello" | "world" | true | 1[] | undefined;
+    if (x.constructor === String) {
+      x.length;
+    }
+
+    if (x.constructor === Number) {
+        x.toFixed();
+    }
+
+    if (x.constructor === Boolean) {
+        const b = x;
+    }
+
+    if(x.constructor === Array) {
+        const c = x[0];
+    }
+
+
+    class Bar {
+        a: string
+    }
+
+    class Baz {
+        a: string
+    }
+    var bar: Bar | Baz;
+    if (bar.constructor === Baz) {
+        const baz = bar
+    }