No constituent of type 'Function | (T & Function)' is callable.

Bug Report

🔎 Search Terms

generic function union-type call-signatures

🕗 Version & Regression Information

• This is a crash
• This is the behavior in every version I tried, and I reviewed the FAQ for entries about Generics
• I was unable to test this on prior versions because _______

⏯ Playground Link

Playground link with relevant code

💻 Code

type Test = <T>(fn: T | Function) => void;
const test: Test = (fn) => {
  return typeof fn === 'function' ? fn() : null;
};
// This expression is not callable.
// No constituent of type 'Function | (T & Function)' is callable.

🙁 Actual behavior

Compiler throw error: This expression is not callable. Not all constituents of type ‘Function | (T & Function)’ are callable.

🙂 Expected behavior

Compile success

because both ‘Function | (T & Function)’ are callable.

[andrewbranch]

This changed between versions 4.3.5 and Nightly

It didn’t—it’s always been this way.

I think the behavior is correct but the error message is (very) wrong. What it means to say, I think, is that T might be a function, and if it is, you have no idea what its signature looks like, so calling it with zero arguments is not allowed. If you give T some constraint that implies it’s not a function, like T extends object or T extends string, it becomes callable after narrowing. But to say that “no constituent is callable” is certainly wrong.

[yellowsink]

I should note that while it is true that technically, should T be a function, it would be impossible to safely call it, this issue is actually quite easy to hit in a situation where logically it should not be, using typeof:

function test<T>(val: Exclude<T, Function> | (() => T)) {
  // val can clealy either not be a function, or be a function that returns a T.

  if (typeof val === "function") {
    // typescript chooses to refine to quite the intriguing type:
    // (Exclude<T, Function> & Function) | (() => T)
    val(); // ERROR: Type 'Exclude<T, Function> & Function' has no call signatures
  }
}

val in this situation should not be callable since it excludes Function, yet it still makes it through.

Not sure if this is worthy of a separate issue or not, but its at least somewhat relevant here since Exclude<T, Function> & Function alone is callable.

EDIT: Another note, you may have more luck using instanceof Function if you want to never treat T as possibly being a function, even if it is one. That fixes the issue in my use case, but won’t in every.