Slow build time on union of enums type as a parameter of generic function.

[h-joo]

Bug Report

Type checking for generic function which the parameter it being specialized with a union of enum and other types has a huge build time.

🔎 Search Terms

big enum, union, performance, slow

🕗 Version & Regression Information

Confirmed with 4.2.4, and recent master branch.( less than one week old)
We started to noticed this slow build from March.

💻 Code

enum BigEnum {
  A0001,
  A0002,
  //  ... until A1998
  A1999,
}
type A = BigEnum | undefined;
// type A = BigEnum | undefined | some_other_type; will cause a drastic increase in build time
function generic<T>(param0: T): void {}
function foo(param: A) {
  generic(param);
  // generic<A>(param); takes almost no time compared to the first statement, since there is no need of type inference.
  // generic(param || something_else); adding another type will also cause a drastic increase in build time
}

🙁 Actual behavior

The build time for a similar code is huge, and it scales up to 10-20 seconds solely for checking the expression similar to generic(param || something_else). The TS library which contains thousands lines of code takes > 200 seconds to build. This is production code and not a made up example.

🙂 Expected behavior

Checking one expression should take much less time, maybe in a scale of hundreds of milliseconds.

Diagnosis

This seems to be a combination of several things.

1. When you type query on enum type, the TSC type system gives a union of all the enum literals, instead of the enum type. I believe this is by design, and not a bug.
2. While doing ts.checkCallExpression on call expressions which are generic, it tries to sqaush the type(in the above case type A) if it's union, and try to get a common super type of all it's elements.
3. If the type given is a huge union, it consumes lots of time in binary search on union types while squshing & figuring out the supertype.