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 Andrew Branch (@andrewbranch)