Fixes #44253

Problem

Object.hasOwn(obj, key) is the modern replacement for obj.hasOwnProperty(key) and the in operator for own-property checks, but TypeScript does not narrow the type of obj after the call:

type Shape = { kind: "circle"; radius: number } | { kind: "square"; side: number };

function f(s: Shape) {
    if (Object.hasOwn(s, "radius")) {
        s.radius; // Error: Property 'radius' does not exist on type 'Shape'
    }

    // Workaround: use "in" operator instead
    if ("radius" in s) {
        s.radius; // OK — "in" narrows, but Object.hasOwn doesn't
    }
}

Approach

30 lines added to narrowTypeByCallExpression() in src/compiler/checker.ts. The implementation:

1. Detects Object.hasOwn(obj, key) calls by checking that the receiver is the global ObjectConstructor
2. Delegates to the existing narrowTypeByInKeyword — same narrowing semantics as the in operator, zero new narrowing logic
3. Same-branch narrowing only — the else branch does not narrow, per @RyanCavanaugh and @DanielRosenwasser's discussion in Support for Object.hasOwn (lib.d.ts and narrowing) #44253 about else-branch semantics (the in operator already narrows in the else branch, but replicating that for Object.hasOwn was not part of this scope)

Before / After

// Discriminated unions
type Shape = { kind: "circle"; radius: number } | { kind: "square"; side: number };
declare const s: Shape;
if (Object.hasOwn(s, "radius")) {
    s;        // Before: Shape          | After: { kind: "circle"; radius: number }
    s.radius; // Before: error          | After: number
}

// Unknown property on object
declare const x: object;
if (Object.hasOwn(x, "foo")) {
    x; // Before: object | After: object & Record<"foo", unknown>
}

// Compounding checks
declare const u: { a: string } | { b: number } | { a: string; b: number };
if (Object.hasOwn(u, "a")) {
    u; // { a: string } | { a: string; b: number }
    if (Object.hasOwn(u, "b")) {
        u; // { a: string; b: number }
    }
}

Edge cases handled

• Aliased Object reference: const Obj = Object; Obj.hasOwn(...) works because we check the type of the receiver, not the identifier name
• Dynamic keys: Object.hasOwn(obj, dynamicVar) with a non-literal key type does not narrow (same as in)
• exactOptionalPropertyTypes: correctly narrows optional property presence via containsMissingType + Record<key, unknown> intersection
• Negated checks: if (!Object.hasOwn(obj, key)) does not narrow in the truthy branch (only same-branch narrowing)
• Else of negation: if (!Object.hasOwn(o, "b")) {} else { o; } — the else branch sees assumeTrue=true via prefix unary inversion, so narrowing applies correctly

Scope

• src/compiler/checker.ts: 30 lines in narrowTypeByCallExpression()
• Test file: tests/cases/compiler/objectHasOwnNarrowing.ts with baseline
• No new narrowing logic — reuses narrowTypeByInKeyword directly