@typescript-bot perf test this

Heya @ahejlsberg, I've started to run the perf test suite on this PR at a0546fc. You can monitor the build here. It should now contribute to this PR's status checks.

Update: The results are in!

@ahejlsberg
The results of the perf run you requested are in!

@ahejlsberg How do these predicates relate to couldContainTypeVariables? Is there a reason these are ObjectFlags and that uses a property?

Context: instantiateType is frequently called on types that can't be instantiated and it seems like we could save some time (~2% on the material-ui benchmark above, in my naive implementation) by checking one or more of these cached values.

How do these predicates relate to couldContainTypeVariables? Is there a reason these are ObjectFlags and that uses a property?

The isGenericObjectType and isGenericIndexType functions are used to determine whether conditional types, indexed access types, and index types should be resolved, or whether resolution should be deferred in a higher-order type of the particular kind. It is possible for these functions to return false even if the given type references type variables, e.g. for the type { foo: T } where T is a type variable.

The couldContainTypeVariables function computes whether a type possibly contains type variables, i.e. whether it possibly could be affected by instantiation. This function may return true even when the type references no type variables because it isn't possible to explore all types fully in depth. There's no good reason for this function to use a dedicated property. An ObjectFlags flag would be better.

In scenarios that are heavy on union and intersection type instantiation, it might make sense to first call couldContainTypeVariables since the cached result would allow us to bail out quicker.

Follow-up questions:

1. Why do we only set those flags on union and intersection types? It looks like we might do non-trivial work for other types?
2. Do we need both sets of flags? I would guess that only one of the two makes sense for any given type or that, if both make sense, only the || of the values matters.

Edit - offline responses:

1. Claim is that it's only expensive for union and intersection types.
2. Yes, the difference matters.