Small tweaks, lint fixes, and baseline updates

Author: rbuckton

src/compiler/checker.ts

@@ -27467,6 +27467,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
             const right = expr.right;
             const rightType = getTypeOfExpression(right);
+            if (!isTypeDerivedFrom(rightType, globalObjectType)) {
+                return type;
+            }
             const instanceType = mapType(rightType, t => getInstanceType(t, left, type, right));
             // Don't narrow from `any` if the target type is exactly `Object` or `Function`, and narrow
             // in the false branch only if the target is a non-empty object type.
@@ -27486,7 +27489,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const syntheticCall = createSyntheticHasInstanceMethodCall(left, leftType, right, constructorType, hasInstanceMethodType);
                 const signature = getEffectsSignature(syntheticCall);
                 const predicate = signature && getTypePredicateOfSignature(signature);
-                if (predicate && predicate.kind == TypePredicateKind.Identifier && predicate.parameterIndex == 0) {
+                if (predicate && predicate.kind === TypePredicateKind.Identifier && predicate.parameterIndex === 0) {
                     return predicate.type;
                 }
                 if (!isTypeDerivedFrom(constructorType, globalFunctionType)) {

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -5144,6 +5144,7 @@ declare namespace ts {
         readonly isSpread: boolean;
         readonly type: Type;
         readonly tupleNameSource?: ParameterDeclaration | NamedTupleMember;
+        readonly thisArgument?: LeftHandSideExpression;
     }
     type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;
     type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;

tests/baselines/reference/api/typescript.d.ts

@@ -1091,6 +1091,7 @@ declare namespace ts {
         readonly isSpread: boolean;
         readonly type: Type;
         readonly tupleNameSource?: ParameterDeclaration | NamedTupleMember;
+        readonly thisArgument?: LeftHandSideExpression;
     }
     type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;
     type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;

tests/baselines/reference/instanceofOperatorWithRHSHasSymbolHasInstance.js

@@ -3,6 +3,7 @@
 //// [instanceofOperatorWithRHSHasSymbolHasInstance.ts]
 interface Point { x: number, y: number }
 interface Point3D { x: number, y: number, z: number }
+interface Point3D2 extends Point { z: number }
 interface Line { start: Point, end: Point }
 
 declare var rhs0: { [Symbol.hasInstance](value: unknown): boolean; };
@@ -25,6 +26,7 @@ declare var lhs0: any;
 declare var lhs1: object;
 declare var lhs2: Point | Point3D | Line;
 declare var lhs3: Point3D | Line;
+declare var lhs4: Point | Point3D2 | Line;
 
 lhs0 instanceof rhs0 && lhs0;
 lhs0 instanceof rhs1 && lhs0;
@@ -75,7 +77,45 @@ lhs3 instanceof Rhs10 && lhs3;
 lhs3 instanceof Rhs11 && lhs3;
 lhs3 instanceof Rhs12 && lhs3;
 lhs3 instanceof Rhs13 && lhs3;
-
+
+lhs4 instanceof rhs0 && lhs4;
+lhs4 instanceof rhs1 && lhs4;
+lhs4 instanceof rhs2 && lhs4;
+lhs4 instanceof rhs3 && lhs4;
+lhs4 instanceof rhs4 && lhs4;
+lhs4 instanceof rhs5 && lhs4;
+lhs4 instanceof Rhs7 && lhs4;
+lhs4 instanceof Rhs8 && lhs4;
+lhs4 instanceof Rhs9 && lhs4;
+lhs4 instanceof Rhs10 && lhs4;
+lhs4 instanceof Rhs11 && lhs4;
+lhs4 instanceof Rhs12 && lhs4;
+
+declare class A {
+    #x: number;
+
+    // approximation of `getInstanceType` behavior, with one caveat: the checker versions unions the return types of
+    // all construct signatures, but we have no way of extracting individual construct signatures from a type.
+    static [Symbol.hasInstance]<T>(this: T, value: unknown): value is (
+        T extends globalThis.Function ?
+            T extends { readonly prototype: infer U } ?
+                boolean extends (U extends never ? true : false) ? // <- tests whether 'U' is 'any'
+                    T extends (abstract new (...args: any) => infer V) ? V : {} :
+                U :
+            never :
+        never
+    );
+}
+
+declare class B extends A { #y: number; }
+
+declare const obj: unknown;
+if (obj instanceof A) {
+    obj; // A
+}
+if (obj instanceof B) {
+    obj; // B
+}
 
 //// [instanceofOperatorWithRHSHasSymbolHasInstance.js]
 lhs0 instanceof rhs0 && lhs0;
@@ -124,3 +164,21 @@ lhs3 instanceof Rhs10 && lhs3;
 lhs3 instanceof Rhs11 && lhs3;
 lhs3 instanceof Rhs12 && lhs3;
 lhs3 instanceof Rhs13 && lhs3;
+lhs4 instanceof rhs0 && lhs4;
+lhs4 instanceof rhs1 && lhs4;
+lhs4 instanceof rhs2 && lhs4;
+lhs4 instanceof rhs3 && lhs4;
+lhs4 instanceof rhs4 && lhs4;
+lhs4 instanceof rhs5 && lhs4;
+lhs4 instanceof Rhs7 && lhs4;
+lhs4 instanceof Rhs8 && lhs4;
+lhs4 instanceof Rhs9 && lhs4;
+lhs4 instanceof Rhs10 && lhs4;
+lhs4 instanceof Rhs11 && lhs4;
+lhs4 instanceof Rhs12 && lhs4;
+if (obj instanceof A) {
+    obj; // A
+}
+if (obj instanceof B) {
+    obj; // B
+}