Revert to using an existing mapper, use permissive > restrictive

Author: weswigham

src/compiler/checker.ts

@@ -2786,7 +2786,6 @@ namespace ts {
         function createTypeParameter(symbol?: Symbol) {
             const type = <TypeParameter>createType(TypeFlags.TypeParameter);
             if (symbol) type.symbol = symbol;
-            type.calculatedFlags = CalculatedTypeFlags.HasCalculatedContainsTypeParameter | CalculatedTypeFlags.ContainsTypeParameter;
             return type;
         }
 
@@ -12610,7 +12609,7 @@ namespace ts {
                 // the order in which things were checked.
                 if (source.flags & (TypeFlags.Object | TypeFlags.Conditional) && source.aliasSymbol &&
                     source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol &&
-                    !(source.calculatedFlags! & CalculatedTypeFlags.IsMarkerType || target.calculatedFlags! & CalculatedTypeFlags.IsMarkerType)) {
+                    !(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) {
                     const variances = getAliasVariances(source.aliasSymbol);
                     const varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances);
                     if (varianceResult !== undefined) {
@@ -12825,7 +12824,13 @@ namespace ts {
                 return Ternary.False;
 
                 function isNonGeneric(type: Type) {
-                    return !hasAggregatedCalculatedFlag(type, CalculatedTypeFlags.ContainsTypeParameter);
+                    // If we're already in identity relationship checking, we should use `isRelatedTo`
+                    // to catch the `Maybe` from an excessively deep type (which we then assume means
+                    // that the type could possibly contain a generic)
+                    if (relation === identityRelation) {
+                        return isRelatedTo(type, getPermissiveInstantiation(type)) === Ternary.True;
+                    }
+                    return isTypeIdenticalTo(type, getPermissiveInstantiation(type));
                 }
 
                 function relateVariances(sourceTypeArguments: ReadonlyArray<Type> | undefined, targetTypeArguments: ReadonlyArray<Type> | undefined, variances: Variance[]) {
@@ -12862,110 +12867,6 @@ namespace ts {
                 }
             }
 
-            function hasAggregatedCalculatedFlag(type: Type, storageBit: CalculatedTypeFlags) {
-                const checkedBit = storageBit >> 1;
-                const visited = createMap<true>();
-                return visitType(type);
-
-                function visitType(type: Type): boolean {
-                    const id = "" + getTypeId(type);
-                    if (visited.has(id)) return false;
-                    visited.set(id, true);
-                    const flags = type.flags;
-                    if (type.calculatedFlags! & checkedBit) {
-                        return !!(type.calculatedFlags! & storageBit);
-                    }
-                    if (flags & TypeFlags.Object) {
-                        const objectFlags = (<ObjectType>type).objectFlags;
-                        if (isGenericMappedType(type)) {
-                            return cacheResult(type, visitType(getConstraintTypeFromMappedType(type)) || visitType(getTemplateTypeFromMappedType(type)));
-                        }
-                        else if (objectFlags & ObjectFlags.ReverseMapped) {
-                            return cacheResult(type, visitType((type as ReverseMappedType).mappedType) ||
-                                visitType((type as ReverseMappedType).source) ||
-                                visitType((type as ReverseMappedType).constraintType));
-                        }
-                        else if (objectFlags & (ObjectFlags.Anonymous | ObjectFlags.Mapped | ObjectFlags.ClassOrInterface)) {
-                            return cacheResult(type, visitStructuredType(type as StructuredType));
-                        }
-                        else if (objectFlags & ObjectFlags.Reference) {
-                            const typeArguments = (<TypeReference>type).typeArguments;
-                            return cacheResult(type, some(typeArguments, visitType));
-                        }
-                    }
-                    else if (flags & TypeFlags.UnionOrIntersection) {
-                        return cacheResult(type, some((type as UnionOrIntersectionType).types, visitType));
-                    }
-                    else if (flags & TypeFlags.Index) {
-                        return cacheResult(type, visitType((type as IndexType).type));
-                    }
-                    else if (flags & TypeFlags.IndexedAccess) {
-                        return cacheResult(type, visitType((type as IndexedAccessType).objectType) ||
-                            visitType((type as IndexedAccessType).indexType));
-                    }
-                    else if (flags & TypeFlags.Conditional) {
-                        return cacheResult(type, visitType((type as ConditionalType).checkType) ||
-                            visitType((type as ConditionalType).extendsType) ||
-                            visitType(getTrueTypeFromConditionalType(type as ConditionalType)) ||
-                            visitType(getFalseTypeFromConditionalType(type as ConditionalType)));
-                    }
-                    else if (flags & TypeFlags.Substitution) {
-                        return cacheResult(type, visitType((type as SubstitutionType).typeVariable) ||
-                            visitType((type as SubstitutionType).substitute));
-                    }
-                    return false;
-                }
-
-                function cacheResult(type: Type, result: boolean) {
-                    type.calculatedFlags! |= checkedBit;
-                    if (result) {
-                        type.calculatedFlags! |= storageBit;
-                    }
-                    return result;
-                }
-
-                function visitStructuredType(type: StructuredType) {
-                    resolveStructuredTypeMembers(type);
-                    const strIdx = getIndexInfoOfType(type, IndexKind.String);
-                    if (strIdx) {
-                        if (visitType(strIdx.type)) {
-                            return true;
-                        }
-                    }
-                    const numIdx = getIndexInfoOfType(type, IndexKind.Number);
-                    if (numIdx) {
-                        if (visitType(numIdx.type)) {
-                            return true;
-                        }
-                    }
-                    for (const sig of getSignaturesOfStructuredType(type, SignatureKind.Call)) {
-                        if (visitSignature(sig)) {
-                            return true;
-                        }
-                    }
-                    for (const sig of getSignaturesOfStructuredType(type, SignatureKind.Construct)) {
-                        if (visitSignature(sig)) {
-                            return true;
-                        }
-                    }
-                    for (const member of ((type as ResolvedType).properties || emptyArray)) {
-                        if (visitType(getTypeOfSymbol(member))) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-
-                function visitSignature(sig: Signature) {
-                    for (const param of sig.parameters) {
-                        if (visitType(getTypeOfSymbol(param))) {
-                            return true;
-                        }
-                    }
-                    return visitType(getReturnTypeOfSignature(sig));
-                }
-            }
-
             // A type [P in S]: X is related to a type [Q in T]: Y if T is related to S and X' is
             // related to Y, where X' is an instantiation of X in which P is replaced with Q. Notice
             // that S and T are contra-variant whereas X and Y are co-variant.
@@ -13431,7 +13332,7 @@ namespace ts {
             const links = getSymbolLinks(symbol);
             return getVariancesWorker(links.typeParameters, links, (_links, param, marker) => {
                 const type = getTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters!, makeUnaryTypeMapper(param, marker)));
-                type.calculatedFlags! |= CalculatedTypeFlags.IsMarkerType;
+                type.aliasTypeArgumentsContainsMarker = true;
                 return type;
             });
         }

src/compiler/types.ts

@@ -3919,7 +3919,7 @@ namespace ts {
         pattern?: DestructuringPattern;  // Destructuring pattern represented by type (if any)
         aliasSymbol?: Symbol;            // Alias associated with type
         aliasTypeArguments?: ReadonlyArray<Type>;     // Alias type arguments (if any)
-        /* @internal */ calculatedFlags?: CalculatedTypeFlags;
+        /* @internal */ aliasTypeArgumentsContainsMarker?: boolean;   // Alias type arguments (if any)
         /* @internal */
         permissiveInstantiation?: Type;  // Instantiation with type parameters mapped to wildcard type
         /* @internal */
@@ -3928,13 +3928,6 @@ namespace ts {
         immediateBaseConstraint?: Type;  // Immediate base constraint cache
     }
 
-    /* @internal */
-    export const enum CalculatedTypeFlags {
-        IsMarkerType                        = 1 << 0,
-        HasCalculatedContainsTypeParameter  = 1 << 1,
-        ContainsTypeParameter               = 1 << 2,
-    }
-
     /* @internal */
     // Intrinsic types (TypeFlags.Intrinsic)
     export interface IntrinsicType extends Type {

tests/baselines/reference/callsOnComplexSignatures.types

@@ -358,22 +358,22 @@ function test5() {
 
     // Union of all intrinsics and components of `any`
     function App(props: { component:React.ReactType }) {
->App : (props: { component: string | React.ComponentClass<any, any> | React.StatelessComponent<any>; }) => JSX.Element
->props : { component: string | React.ComponentClass<any, any> | React.StatelessComponent<any>; }
->component : string | React.ComponentClass<any, any> | React.StatelessComponent<any>
+>App : (props: { component: React.ReactType<any>; }) => JSX.Element
+>props : { component: React.ReactType<any>; }
+>component : React.ReactType<any>
 >React : any
 
         const Comp: React.ReactType = props.component;
->Comp : string | React.ComponentClass<any, any> | React.StatelessComponent<any>
+>Comp : React.ReactType<any>
 >React : any
->props.component : string | React.ComponentClass<any, any> | React.StatelessComponent<any>
->props : { component: string | React.ComponentClass<any, any> | React.StatelessComponent<any>; }
->component : string | React.ComponentClass<any, any> | React.StatelessComponent<any>
+>props.component : React.ReactType<any>
+>props : { component: React.ReactType<any>; }
+>component : React.ReactType<any>
 
         return (<Comp />);
 >(<Comp />) : JSX.Element
 ><Comp /> : JSX.Element
->Comp : string | React.ComponentClass<any, any> | React.StatelessComponent<any>
+>Comp : React.ReactType<any>
     }
 
     // custom components with non-subset props