Type narrowing based on function typeof is broken when function is intersected with a record

[safareli]

Bug Report

🔎 Search Terms

type narrowing based on function typeof is broken when intersection with a record is used

🕗 Version & Regression Information

• Recent change in behaviour happened in version 4.3.5

⏯ Playground Link

Playground link with relevant code

💻 Code

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 {
        // expected: string
        // ts.version >= 4.3.5: string -- expected
        // ts.version <= 4.2.3: string | (F & Meta) -- unexpected
        a;
    }
}

🙁 Actual behavior

behavior was half correct from in TS versions <= 4.2.3, but then it was changed in 4.3.5 which fixed the part that was wrong previously, but broke the other part that was correct. So we still have half broken behavior.

🙂 Expected behavior

It's expected to pick the correct parts from the both versions.

[a-tarasyuk]

It's a little bit tricky case. The previous versions used | for Union and Intersection types

function getTypeFactsOfTypes(types: Type[]): TypeFacts {
    let result: TypeFacts = TypeFacts.None;
    for (const t of types) {
        result |= getTypeFacts(t);
    }
    return result;
}

Currently, TS separates Union and Intersection. To get a type in if block, all types should follow the same flags

interface A { (): number; }
interface B { (): string; }
interface C { (): void; }

const x = (a: (A & B & C) | string) => {
    if (typeof a === "function"){
        a; // A & B ((FunctionFacts & FunctionFacts) & TypeofEQFunction
)
    }
    else {
        a; // string 
    }
}

Or to be empty

interface A { (): number; }
type B = {};

const x = (a: (A & B) | string) => {
    if (typeof a === "function"){
        a; // A
)
    }
    else {
        a; // string 
    }
}

if (flags & TypeFlags.Intersection) {
    // When an intersection contains a primitive type we ignore object type constituents as they are
    // presumably type tags. For example, in string & { __kind__: "name" } we ignore the object type.
    ignoreObjects ||= maybeTypeOfKind(type, TypeFlags.Primitive);
    return reduceLeft((type as UnionType).types, (facts, t) => facts & getTypeFacts(t, ignoreObjects), TypeFacts.All);
}

I'm not sure which fix is appropriate for such cases. Should the TS allow a intersection with the non-empty object and functions?

/cc @andrewbranch