Always fully compute variances structurally

Author: ahejlsberg

src/compiler/checker.ts

@@ -346,9 +346,6 @@ namespace ts {
         let instantiationCount = 0;
         let instantiationDepth = 0;
         let inlineLevel = 0;
-        let varianceLevel = 0;
-        let nestedVarianceSymbols: Symbol[] | undefined;
-        let incompleteVariancesObserved = false;
         let currentNode: Node | undefined;
 
         const emptySymbols = createSymbolTable();
@@ -16629,6 +16626,7 @@ namespace ts {
             return result;
         }
 
+
         function getObjectTypeInstantiation(type: AnonymousType | DeferredTypeReference, mapper: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]) {
             const declaration = type.objectFlags & ObjectFlags.Reference ? (type as TypeReference).node! :
                 type.objectFlags & ObjectFlags.InstantiationExpressionType ? (type as InstantiationExpressionType).node :
@@ -16686,15 +16684,16 @@ namespace ts {
         }
 
         function isTypeParameterPossiblyReferenced(tp: TypeParameter, node: Node) {
-            // If the type parameter doesn't have exactly one declaration, if there are invening statement blocks
-            // between the node and the type parameter declaration, if the node contains actual references to the
-            // type parameter, or if the node contains type queries, we consider the type parameter possibly referenced.
-            if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) {
-                const container = tp.symbol.declarations[0].parent;
-                for (let n = node; n !== container; n = n.parent) {
+            // If there are intervening statement blocks between the node and the type parameter declaration, if the node
+            // contains actual references to the type parameter, or if the node contains type queries, we consider the
+            // type parameter possibly referenced.
+            if (tp.symbol && tp.symbol.declarations) {
+                let n = node;
+                while (!some(tp.symbol.declarations, d => n === d.parent)) {
                     if (!n || n.kind === SyntaxKind.Block || n.kind === SyntaxKind.ConditionalType && forEachChild((n as ConditionalTypeNode).extendsType, containsReference)) {
                         return true;
                     }
+                    n = n.parent;
                 }
                 return containsReference(node);
             }
@@ -19052,16 +19051,13 @@ namespace ts {
                 // We limit alias variance probing to only object and conditional types since their alias behavior
                 // is more predictable than other, interned types, which may or may not have an alias depending on
                 // the order in which things were checked.
-                if (sourceFlags & (TypeFlags.Object | TypeFlags.Conditional) && source.aliasSymbol &&
-                    source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol &&
-                    !(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) {
+                if (sourceFlags & (TypeFlags.Object | TypeFlags.Conditional) && source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) {
                     const variances = getAliasVariances(source.aliasSymbol);
-                    if (variances === emptyArray) {
-                        return Ternary.Unknown;
-                    }
-                    const varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState);
-                    if (varianceResult !== undefined) {
-                        return varianceResult;
+                    if (variances !== emptyArray) {
+                        const varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState);
+                        if (varianceResult !== undefined) {
+                            return varianceResult;
+                        }
                     }
                 }
 
@@ -19432,26 +19428,21 @@ namespace ts {
                     else if (isGenericMappedType(source)) {
                         return Ternary.False;
                     }
-                    if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source as TypeReference).target === (target as TypeReference).target &&
-                        !isTupleType(source) && !(getObjectFlags(source) & ObjectFlags.MarkerType || getObjectFlags(target) & ObjectFlags.MarkerType)) {
+                    if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source as TypeReference).target === (target as TypeReference).target && !isTupleType(source)) {
                         // When strictNullChecks is disabled, the element type of the empty array literal is undefinedWideningType,
                         // and an empty array literal wouldn't be assignable to a `never[]` without this check.
                         if (isEmptyArrayLiteralType(source)) {
                             return Ternary.True;
                         }
-                        // We have type references to the same generic type, and the type references are not marker
-                        // type references (which are intended by be compared structurally). Obtain the variance
-                        // information for the type parameters and relate the type arguments accordingly.
+                        // We have type references to the same generic type. Obtain the variance information for the type
+                        // parameters and relate the type arguments accordingly. If variance information for the type is in
+                        // the process of being computed, fall through and relate the type references structurally.
                         const variances = getVariances((source as TypeReference).target);
-                        // We return Ternary.Maybe for a recursive invocation of getVariances (signalled by emptyArray). This
-                        // effectively means we measure variance only from type parameter occurrences that aren't nested in
-                        // recursive instantiations of the generic type.
-                        if (variances === emptyArray) {
-                            return Ternary.Unknown;
-                        }
-                        const varianceResult = relateVariances(getTypeArguments(source as TypeReference), getTypeArguments(target as TypeReference), variances, intersectionState);
-                        if (varianceResult !== undefined) {
-                            return varianceResult;
+                        if (variances !== emptyArray) {
+                            const varianceResult = relateVariances(getTypeArguments(source as TypeReference), getTypeArguments(target as TypeReference), variances, intersectionState);
+                            if (varianceResult !== undefined) {
+                                return varianceResult;
+                            }
                         }
                     }
                     else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {
@@ -20371,45 +20362,24 @@ namespace ts {
 
         function getVariances(type: GenericType): VarianceFlags[] {
             // Arrays and tuples are known to be covariant, no need to spend time computing this.
-            if (type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & ObjectFlags.Tuple) {
-                return arrayVariances;
-            }
-            return getVariancesWorker(type.symbol, type.typeParameters, getMarkerTypeReference);
-        }
-
-        // Return a type reference where the source type parameter is replaced with the target marker
-        // type, and flag the result as a marker type reference.
-        function getMarkerTypeReference(symbol: Symbol, source: TypeParameter, target: Type) {
-            const type = getDeclaredTypeOfSymbol(symbol) as GenericType;
-            const result = createTypeReference(type, map(type.typeParameters, t => t === source ? target : t));
-            result.objectFlags |= ObjectFlags.MarkerType;
-            return result;
+            return type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & ObjectFlags.Tuple ?
+                arrayVariances :
+                getVariancesWorker(type.symbol, type.typeParameters);
         }
 
         function getAliasVariances(symbol: Symbol) {
-            return getVariancesWorker(symbol, getSymbolLinks(symbol).typeParameters, getMarkerTypeAliasReference);
-        }
-
-        function getMarkerTypeAliasReference(symbol: Symbol, source: TypeParameter, target: Type) {
-            const result = getTypeAliasInstantiation(symbol, instantiateTypes(getSymbolLinks(symbol).typeParameters!, makeUnaryTypeMapper(source, target)));
-            result.aliasTypeArgumentsContainsMarker = true;
-            return result;
+            return getVariancesWorker(symbol, getSymbolLinks(symbol).typeParameters);
         }
 
         // Return an array containing the variance of each type parameter. The variance is effectively
         // a digest of the type comparisons that occur for each type argument when instantiations of the
         // generic type are structurally compared. We infer the variance information by comparing
         // instantiations of the generic type for type arguments with known relations. The function
         // returns the emptyArray singleton when invoked recursively for the given generic type.
-        function getVariancesWorker(symbol: Symbol, typeParameters: readonly TypeParameter[] = emptyArray, createMarkerType: (symbol: Symbol, param: TypeParameter, marker: Type) => Type): VarianceFlags[] {
+        function getVariancesWorker(symbol: Symbol, typeParameters: readonly TypeParameter[] = emptyArray): VarianceFlags[] {
             const links = getSymbolLinks(symbol);
             if (!links.variances) {
                 tracing?.push(tracing.Phase.CheckTypes, "getVariancesWorker", { arity: typeParameters.length, id: getSymbolId(symbol) });
-                if (varianceLevel > 0) {
-                    nestedVarianceSymbols = append(nestedVarianceSymbols, symbol);
-                }
-                varianceLevel++;
-                // The emptyArray singleton is used to signal a recursive invocation.
                 links.variances = emptyArray;
                 const variances = [];
                 for (const tp of typeParameters) {
@@ -20443,28 +20413,20 @@ namespace ts {
                     variances.push(variance);
                 }
                 links.variances = variances;
-                varianceLevel--;
-                // Recursive invocations of getVariancesWorker occur when two or more types circularly reference each
-                // other. In such cases, the nested invocations might observe in-process variance computations, i.e.
-                // cases where getVariancesWorker returns emptyArray. If that happens we clear (and thus re-compute) the
-                // results of nested variance computations and only permanently record the outermost result. See #44572.
-                if (varianceLevel === 0) {
-                    if (nestedVarianceSymbols && incompleteVariancesObserved) {
-                        for (const sym of nestedVarianceSymbols) {
-                            getSymbolLinks(sym).variances = undefined;
-                        }
-                    }
-                    nestedVarianceSymbols = undefined;
-                    incompleteVariancesObserved = false;
-                }
                 tracing?.pop();
             }
-            else {
-                incompleteVariancesObserved ||= links.variances === emptyArray;
-            }
             return links.variances;
         }
 
+        function createMarkerType(symbol: Symbol, source: TypeParameter, target: Type) {
+            const mapper = makeUnaryTypeMapper(source, target);
+            if (symbol.flags & SymbolFlags.TypeAlias) {
+                return getTypeAliasInstantiation(symbol, instantiateTypes(getSymbolLinks(symbol).typeParameters!, mapper));
+            }
+            const type = getDeclaredTypeOfSymbol(symbol) as GenericType;
+            return createTypeReference(type, instantiateTypes(type.typeParameters, mapper));
+        }
+
         // Return true if the given type reference has a 'void' type argument for a covariant type parameter.
         // See comment at call in recursiveTypeRelatedTo for when this case matters.
         function hasCovariantVoidArgument(typeArguments: readonly Type[], variances: VarianceFlags[]): boolean {

src/compiler/types.ts

@@ -5227,7 +5227,6 @@ namespace ts {
         pattern?: DestructuringPattern;  // Destructuring pattern represented by type (if any)
         aliasSymbol?: Symbol;            // Alias associated with type
         aliasTypeArguments?: readonly Type[]; // Alias type arguments (if any)
-        /* @internal */ aliasTypeArgumentsContainsMarker?: boolean; // Alias type arguments (if any)
         /* @internal */
         permissiveInstantiation?: Type;  // Instantiation with type parameters mapped to wildcard type
         /* @internal */
@@ -5306,22 +5305,21 @@ namespace ts {
         ObjectLiteralPatternWithComputedProperties = 1 << 9,  // Object literal pattern with computed properties
         ReverseMapped    = 1 << 10, // Object contains a property from a reverse-mapped type
         JsxAttributes    = 1 << 11, // Jsx attributes type
-        MarkerType       = 1 << 12, // Marker type used for variance probing
-        JSLiteral        = 1 << 13, // Object type declared in JS - disables errors on read/write of nonexisting members
-        FreshLiteral     = 1 << 14, // Fresh object literal
-        ArrayLiteral     = 1 << 15, // Originates in an array literal
+        JSLiteral        = 1 << 12, // Object type declared in JS - disables errors on read/write of nonexisting members
+        FreshLiteral     = 1 << 13, // Fresh object literal
+        ArrayLiteral     = 1 << 14, // Originates in an array literal
         /* @internal */
-        PrimitiveUnion   = 1 << 16, // Union of only primitive types
+        PrimitiveUnion   = 1 << 15, // Union of only primitive types
         /* @internal */
-        ContainsWideningType = 1 << 17, // Type is or contains undefined or null widening type
+        ContainsWideningType = 1 << 16, // Type is or contains undefined or null widening type
         /* @internal */
-        ContainsObjectOrArrayLiteral = 1 << 18, // Type is or contains object literal type
+        ContainsObjectOrArrayLiteral = 1 << 17, // Type is or contains object literal type
         /* @internal */
-        NonInferrableType = 1 << 19, // Type is or contains anyFunctionType or silentNeverType
+        NonInferrableType = 1 << 18, // Type is or contains anyFunctionType or silentNeverType
         /* @internal */
-        CouldContainTypeVariablesComputed = 1 << 20, // CouldContainTypeVariables flag has been computed
+        CouldContainTypeVariablesComputed = 1 << 19, // CouldContainTypeVariables flag has been computed
         /* @internal */
-        CouldContainTypeVariables = 1 << 21, // Type could contain a type variable
+        CouldContainTypeVariables = 1 << 20, // Type could contain a type variable
 
         ClassOrInterface = Class | Interface,
         /* @internal */
@@ -5333,36 +5331,36 @@ namespace ts {
         ObjectTypeKindMask = ClassOrInterface | Reference | Tuple | Anonymous | Mapped | ReverseMapped | EvolvingArray,
 
         // Flags that require TypeFlags.Object
-        ContainsSpread   = 1 << 22,  // Object literal contains spread operation
-        ObjectRestType   = 1 << 23,  // Originates in object rest declaration
-        InstantiationExpressionType = 1 << 24,  // Originates in instantiation expression
+        ContainsSpread   = 1 << 21,  // Object literal contains spread operation
+        ObjectRestType   = 1 << 22,  // Originates in object rest declaration
+        InstantiationExpressionType = 1 << 23,  // Originates in instantiation expression
         /* @internal */
-        IsClassInstanceClone = 1 << 25, // Type is a clone of a class instance type
+        IsClassInstanceClone = 1 << 24, // Type is a clone of a class instance type
         // Flags that require TypeFlags.Object and ObjectFlags.Reference
         /* @internal */
-        IdenticalBaseTypeCalculated = 1 << 26, // has had `getSingleBaseForNonAugmentingSubtype` invoked on it already
+        IdenticalBaseTypeCalculated = 1 << 25, // has had `getSingleBaseForNonAugmentingSubtype` invoked on it already
         /* @internal */
-        IdenticalBaseTypeExists = 1 << 27, // has a defined cachedEquivalentBaseType member
+        IdenticalBaseTypeExists = 1 << 26, // has a defined cachedEquivalentBaseType member
 
         // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution
         /* @internal */
-        IsGenericTypeComputed = 1 << 22, // IsGenericObjectType flag has been computed
+        IsGenericTypeComputed = 1 << 21, // IsGenericObjectType flag has been computed
         /* @internal */
-        IsGenericObjectType = 1 << 23, // Union or intersection contains generic object type
+        IsGenericObjectType = 1 << 22, // Union or intersection contains generic object type
         /* @internal */
-        IsGenericIndexType = 1 << 24, // Union or intersection contains generic index type
+        IsGenericIndexType = 1 << 23, // Union or intersection contains generic index type
         /* @internal */
         IsGenericType = IsGenericObjectType | IsGenericIndexType,
 
         // Flags that require TypeFlags.Union
         /* @internal */
-        ContainsIntersections = 1 << 25, // Union contains intersections
+        ContainsIntersections = 1 << 24, // Union contains intersections
 
         // Flags that require TypeFlags.Intersection
         /* @internal */
-        IsNeverIntersectionComputed = 1 << 25, // IsNeverLike flag has been computed
+        IsNeverIntersectionComputed = 1 << 24, // IsNeverLike flag has been computed
         /* @internal */
-        IsNeverIntersection = 1 << 26, // Intersection reduces to never
+        IsNeverIntersection = 1 << 25, // Intersection reduces to never
     }
 
     /* @internal */