@zzzen/pyright-internal 1.2.0-dev.20221204 → 1.2.0-dev.20221218

package/dist/analyzer/typeEvaluator.js

@@ -205,6 +205,12 @@ const maxOverloadUnionExpansionCount = 64;
 // Maximum number of recursive function return type inference attempts
 // that can be concurrently pending before we give up.
 const maxInferFunctionReturnRecursionCount = 12;
+// Maximum recursion amount when comparing two recursive type aliases.
+// Increasing this can greatly increase the time required to evaluate
+// two recursive type aliases that have the same definition. Decreasing
+// it can increase the chance of false negatives for such recursive
+// type aliases.
+const maxRecursiveTypeAliasRecursionCount = 10;
 // This switch enables a special debug mode that attempts to catch
 // bugs due to inconsistent evaluation flags used when reading types
 // from the type cache.
@@ -697,7 +703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (flags & 65536 /* DisallowRecursiveTypeAliasPlaceholder */) {
-            if ((0, typeUtils_1.isTypeAliasPlaceholder)(typeResult.type)) {
+            if ((0, types_1.isTypeVar)(typeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(typeResult.type)) {
                 typeResult.type.details.illegalRecursionDetected = true;
             }
         }
@@ -1980,6 +1986,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (diagLevel === 'none') {
             return undefined;
         }
+        // Should we suppress this diagnostic because it's within an unannotated function?
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        if (!fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions) {
+            const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
+            // Is the target node within the body of the function? If so, suppress the diagnostic.
+            if (containingFunction &&
+                ParseTreeUtils.isUnannotatedFunction(containingFunction) &&
+                ParseTreeUtils.isNodeContainedWithin(node, containingFunction.suite)) {
+                return undefined;
+            }
+        }
         const diagnostic = addDiagnosticWithSuppressionCheck(diagLevel, message, node, range);
         if (diagnostic) {
             diagnostic.setRule(rule);
@@ -2752,15 +2769,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let type;
         let isIncomplete = false;
         const allowForwardReferences = (flags & 4 /* AllowForwardReferences */) !== 0 || fileInfo.isStubFile;
-        if (!evaluatorOptions.analyzeUnannotatedFunctions) {
-            const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
-            if (containingFunction && ParseTreeUtils.isUnannotatedFunction(containingFunction)) {
-                return {
-                    type: types_1.AnyType.create(),
-                    isIncomplete: false,
-                };
-            }
-        }
         // Does this name refer to a PEP 695-style type parameter?
         const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
         if (typeParamSymbol) {
@@ -2789,6 +2797,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     useCodeFlowAnalysis = false;
                 }
                 symbol = symbolWithScope.symbol;
+                setSymbolAccessed(fileInfo, symbol, node);
+                // If we're not supposed to be analyzing this function, skip the remaining work
+                // to determine the name's type. Simply evaluate its type as Any.
+                if (!fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions) {
+                    const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
+                    if (containingFunction && ParseTreeUtils.isUnannotatedFunction(containingFunction)) {
+                        return {
+                            type: types_1.AnyType.create(),
+                            isIncomplete: false,
+                        };
+                    }
+                }
                 // Get the effective type (either the declared type or the inferred type).
                 // If we're using code flow analysis, pass the usage node so we consider
                 // only the assignment nodes that are reachable from this usage.
@@ -2845,7 +2865,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // Detect, report, and fill in missing type arguments if appropriate.
                 type = reportMissingTypeArguments(node, type, flags);
-                setSymbolAccessed(fileInfo, symbol, node);
                 if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
                     // Verify that the name does not refer to a (non type alias) variable.
                     if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
@@ -4402,7 +4421,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeAliasResult) {
             return typeAliasResult;
         }
-        if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
+        if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
             const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
             return { type };
@@ -4499,14 +4518,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return typeResult.type;
             }
-            if ((0, types_1.isNever)(concreteSubtype)) {
-                return types_1.UnknownType.create();
+            if ((0, types_1.isNever)(concreteSubtype) || (0, types_1.isUnbound)(concreteSubtype)) {
+                return types_1.NeverType.createNever();
             }
             if ((0, types_1.isNoneInstance)(concreteSubtype) && !isIncomplete) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalSubscript, diagnosticRules_1.DiagnosticRule.reportOptionalSubscript, localize_1.Localizer.Diagnostic.noneNotSubscriptable(), node.baseExpression);
                 return types_1.UnknownType.create();
             }
-            if (!(0, types_1.isUnbound)(concreteSubtype) && !isIncomplete) {
+            if (!isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
             }
@@ -5363,6 +5382,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let matchedOverload;
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
             const hasArgTypeOverride = argTypeOverride.some((a) => a !== undefined);
+            const possibleMatchResults = [];
+            let isDefinitiveMatchFound = false;
             for (let overloadIndex = 0; overloadIndex < argParamMatches.length; overloadIndex++) {
                 const overload = argParamMatches[overloadIndex].overload;
                 let matchResults = argParamMatches[overloadIndex];
@@ -5402,10 +5423,44 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         matchResults,
                         typeVarContext: effectiveTypeVarContext,
                     });
-                    returnTypes.push(callResult.returnType);
-                    break;
+                    if (callResult.isArgumentAnyOrUnknown) {
+                        possibleMatchResults.push(callResult.returnType);
+                    }
+                    else {
+                        returnTypes.push(callResult.returnType);
+                        isDefinitiveMatchFound = true;
+                        break;
+                    }
                 }
             }
+            // If we didn't find a definitive match that doesn't depend on
+            // an Any or Unknown argument, fall back on the possible match.
+            // If there were multiple possible matches, evaluate the type as
+            // Unknown, but include the "possible types" to allow for completion
+            // suggestions.
+            if (!isDefinitiveMatchFound) {
+                // Eliminate any return types that are subsumed by other return types.
+                let dedupedMatchResults = [];
+                possibleMatchResults.forEach((subtype) => {
+                    let isSubtypeSubsumed = false;
+                    for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
+                        if (assignType(dedupedMatchResults[dedupedIndex], subtype)) {
+                            isSubtypeSubsumed = true;
+                            break;
+                        }
+                        else if (assignType(subtype, dedupedMatchResults[dedupedIndex])) {
+                            dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
+                            break;
+                        }
+                    }
+                    if (!isSubtypeSubsumed) {
+                        dedupedMatchResults.push(subtype);
+                    }
+                });
+                dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
+                const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
+                returnTypes.push(dedupedMatchResults.length > 1 ? types_1.UnknownType.createPossibleType(combinedTypes) : combinedTypes);
+            }
             if (!matchedOverload) {
                 return { argumentErrors: true, isTypeIncomplete };
             }
@@ -5428,6 +5483,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return {
             argumentErrors: false,
+            isArgumentAnyOrUnknown: finalCallResult.isArgumentAnyOrUnknown,
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
             specializedInitSelfType: finalCallResult.specializedInitSelfType,
@@ -5787,7 +5843,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        if (!validatedTypes && argList.length > 0) {
+        if (!validatedTypes && argList.some((arg) => arg.argumentCategory === 0 /* Simple */)) {
             // Suppress this error if the class was instantiated from a custom
             // metaclass because it's likely that it's a false positive. Also
             // suppress the error if the class's metaclass has a __call__ method.
@@ -6974,9 +7030,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 ((0, types_1.isClassInstance)(argType) &&
                                     (0, typeUtils_1.isTupleClass)(argType) &&
                                     argType.tupleTypeArguments &&
-                                    argType.tupleTypeArguments.some((arg) => (0, types_1.isUnpackedVariadicTypeVar)(arg.type)));
+                                    argType.tupleTypeArguments.length === 1 &&
+                                    (0, types_1.isUnpackedVariadicTypeVar)(argType.tupleTypeArguments[0].type));
                             if (containsVariadicTypeVar &&
-                                argParam.argument.argumentCategory !== 1 /* UnpackedList */) {
+                                argParam.argument.argumentCategory !== 1 /* UnpackedList */ &&
+                                !argParam.mapsToVarArgList) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                                 reportedArgError = true;
                             }
@@ -7110,6 +7168,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
         let specializedInitSelfType;
+        let isArgumentAnyOrUnknown = false;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         if (type.boundTypeVarScopeId) {
             // If the function was bound to a class or object and was a constructor, a
@@ -7213,6 +7272,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argResult.condition) {
                 condition = (_a = types_1.TypeCondition.combine(condition, argResult.condition)) !== null && _a !== void 0 ? _a : [];
             }
+            if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
+                isArgumentAnyOrUnknown = true;
+            }
             if (type.details.paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* UnpackedList */) {
                     if ((0, types_1.isParamSpec)(argResult.argType) && argResult.argType.paramSpecAccess === 'args') {
@@ -7308,6 +7370,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return {
             argumentErrors,
+            isArgumentAnyOrUnknown,
             returnType: specializedReturnType,
             isTypeIncomplete,
             activeParam: matchResults.activeParam,
@@ -8248,6 +8311,35 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isUnion)(newUnion)) {
                     types_1.TypeBase.setSpecialForm(newUnion);
                 }
+                // Check for "stringified" forward reference type expressions. The "|" operator
+                // doesn't support these except in certain circumstances. Notably, it can't be used
+                // with other strings or with types that are not specialized using an index form.
+                if (!fileInfo.isStubFile) {
+                    let stringNode;
+                    let otherNode;
+                    let otherType;
+                    if (leftExpression.nodeType === 48 /* StringList */) {
+                        stringNode = leftExpression;
+                        otherNode = rightExpression;
+                        otherType = rightType;
+                    }
+                    else if (rightExpression.nodeType === 48 /* StringList */) {
+                        stringNode = rightExpression;
+                        otherNode = leftExpression;
+                        otherType = leftType;
+                    }
+                    if (stringNode && otherNode && otherType) {
+                        let isAllowed = true;
+                        if ((0, types_1.isClass)(otherType)) {
+                            if (!otherType.isTypeArgumentExplicit || (0, types_1.isClassInstance)(otherType)) {
+                                isAllowed = false;
+                            }
+                        }
+                        if (!isAllowed) {
+                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionForwardReferenceNotAllowed(), stringNode);
+                        }
+                    }
+                }
                 return { type: newUnion };
             }
         }
@@ -8743,13 +8835,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let effectiveExpectedType = expectedType;
         if (expectedType && (0, types_1.isUnion)(expectedType)) {
             let matchingSubtype;
+            let matchingSubtypeResult;
             (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
-                if (!matchingSubtype) {
-                    const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfDictionaryExpected(node, subtype);
-                    });
-                    if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                // Use shortcut if we've already found a match.
+                if (matchingSubtypeResult && !matchingSubtypeResult.typeErrors) {
+                    return;
+                }
+                const subtypeResult = useSpeculativeMode(node, () => {
+                    return getTypeOfDictionaryExpected(node, subtype);
+                });
+                if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                    // If this is the first result we're seeing or it's the first result
+                    // without errors, select it as the match.
+                    if (!matchingSubtypeResult || (matchingSubtypeResult.typeErrors && !subtypeResult.typeErrors)) {
                         matchingSubtype = subtype;
+                        matchingSubtypeResult = subtypeResult;
                     }
                 }
             });
@@ -9011,13 +9111,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let effectiveExpectedType = expectedType;
         if (expectedType && (0, types_1.isUnion)(expectedType)) {
             let matchingSubtype;
+            let matchingSubtypeResult;
             (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
-                if (!matchingSubtype) {
-                    const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfListOrSetExpected(node, subtype);
-                    });
-                    if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                // Use shortcut if we've already found a match.
+                if (matchingSubtypeResult && !matchingSubtypeResult.typeErrors) {
+                    return;
+                }
+                const subtypeResult = useSpeculativeMode(node, () => {
+                    return getTypeOfListOrSetExpected(node, subtype);
+                });
+                if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                    // If this is the first result we're seeing or it's the first result
+                    // without errors, select it as the match.
+                    if (!matchingSubtypeResult || (matchingSubtypeResult.typeErrors && !subtypeResult.typeErrors)) {
                         matchingSubtype = subtype;
+                        matchingSubtypeResult = subtypeResult;
                     }
                 }
             });
@@ -10502,6 +10610,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 let isSpeculativeTypeAlias = false;
                 if (isDeclaredTypeAlias(node.leftExpression)) {
                     typeAliasNameNode = node.leftExpression.valueExpression;
+                    if (!(0, declarationUtils_1.isLegalTypeAliasExpressionForm)(node.rightExpression)) {
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), node.rightExpression);
+                    }
                 }
                 else if (node.leftExpression.nodeType === 38 /* Name */) {
                     const symbolWithScope = lookUpSymbolRecursive(node.leftExpression, node.leftExpression.value, 
@@ -10660,6 +10771,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeParameters = evaluateTypeParameterList(node.typeParameters);
             typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
         }
+        if (!(0, declarationUtils_1.isLegalTypeAliasExpressionForm)(node.expression)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), node.expression);
+        }
         const aliasTypeResult = getTypeOfExpressionExpectingType(node.expression);
         let isIncomplete = false;
         let aliasType = aliasTypeResult.type;
@@ -14716,6 +14830,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         let returnType;
         let isIncomplete = false;
+        let analyzeUnannotatedFunctions = true;
         // Don't attempt to infer the return type for a stub file.
         if (types_1.FunctionType.isStubDefinition(type)) {
             return types_1.UnknownType.create();
@@ -14733,8 +14848,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (type.details.declaration) {
                 const functionNode = type.details.declaration.node;
+                analyzeUnannotatedFunctions =
+                    AnalyzerNodeInfo.getFileInfo(functionNode).diagnosticRuleSet.analyzeUnannotatedFunctions;
                 // Skip return type inference if we are in "skip unannotated function" mode.
-                if (evaluatorOptions.analyzeUnannotatedFunctions && !checkCodeFlowTooComplex(functionNode.suite)) {
+                if (analyzeUnannotatedFunctions && !checkCodeFlowTooComplex(functionNode.suite)) {
                     const codeFlowComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(functionNode);
                     // For very complex functions that have no annotated parameter types,
                     // don't attempt to infer the return type because it can be extremely
@@ -14771,7 +14888,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // params, try to analyze the function with the provided argument types and
         // attempt to do a better job at inference.
         if (!isIncomplete &&
-            evaluatorOptions.analyzeUnannotatedFunctions &&
+            analyzeUnannotatedFunctions &&
             (0, typeUtils_1.isPartlyUnknown)(returnType) &&
             types_1.FunctionType.hasUnannotatedParams(type) &&
             !types_1.FunctionType.isStubDefinition(type) &&
@@ -15405,8 +15522,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Transform recursive type aliases if necessary.
-        destType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(destType);
-        srcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
+        const transformedDestType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(destType);
+        const transformedSrcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
+        // Did both the source and dest include recursive type aliases?
+        // If so, we are potentially dealing with different recursive type
+        // aliases that are defined in the same way.
+        if (transformedDestType !== destType &&
+            transformedSrcType !== srcType &&
+            (0, types_1.isUnion)(transformedDestType) &&
+            (0, types_1.isUnion)(transformedSrcType)) {
+            // Use a smaller recursive limit in this case to prevent runaway recursion.
+            if (recursionCount > maxRecursiveTypeAliasRecursionCount) {
+                return true;
+            }
+        }
+        destType = transformedDestType;
+        srcType = transformedSrcType;
         // If the source or dest is unbound, allow the assignment. The
         // error will be reported elsewhere.
         if ((0, types_1.isUnbound)(destType) || (0, types_1.isUnbound)(srcType)) {
@@ -15628,19 +15759,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 instantiableType = (0, typeUtils_1.convertToInstantiable)(typeTypeArg);
             }
-            else {
+            else if (types_1.TypeBase.isInstantiable(destType)) {
                 typeTypeArg = objectType !== null && objectType !== void 0 ? objectType : types_1.AnyType.create();
                 instantiableType = expandedSrcType;
             }
-            if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
-                if (assignType(destType, instantiableType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                    return true;
+            if (instantiableType && typeTypeArg) {
+                if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
+                    if (assignType(destType, instantiableType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                        return true;
+                    }
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
+                        sourceType: printType(srcType),
+                        destType: printType(destType),
+                    }));
+                    return false;
                 }
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                    sourceType: printType(srcType),
-                    destType: printType(destType),
-                }));
-                return false;
             }
         }
         if ((0, types_1.isInstantiableClass)(destType)) {
@@ -16103,7 +16236,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // in case the destType is a union with hundreds of literals.
                 if ((0, types_1.isClassInstance)(srcType) &&
                     (0, typeUtils_1.isLiteralType)(srcType) &&
-                    types_1.UnionType.containsType(destType, srcType, recursionCount)) {
+                    types_1.UnionType.containsType(destType, srcType, /* exclusionSet */ undefined, recursionCount)) {
                     return true;
                 }
                 (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
@@ -17248,7 +17381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isAnyOrUnknown)(srcType)) {
             return srcType;
         }
-        let effectiveSrcType = srcType;
+        let effectiveSrcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
         if ((0, types_1.isTypeVar)(srcType)) {
             if ((0, types_1.isTypeSame)(srcType, destType)) {
                 return srcType;
@@ -17262,7 +17395,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return srcType;
         }
         // If there's a bound type, make sure the source is derived from it.
-        if (destType.details.boundType) {
+        if (destType.details.boundType && !(0, typeUtils_1.isTypeAliasPlaceholder)(effectiveSrcType)) {
             if (!assignType(destType.details.boundType, effectiveSrcType, diag.createAddendum(), 
             /* destTypeVarContext */ undefined, 
             /* srcTypeVarContext */ undefined)) {
@@ -17303,6 +17436,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (constraints.length === 0) {
             return srcType;
         }
+        if ((0, typeUtils_1.isTypeAliasPlaceholder)(srcType)) {
+            return srcType;
+        }
         if ((0, types_1.isTypeVar)(srcType) && srcType.details.constraints.length > 0) {
             // Make sure all the source constraint types map to constraint types in the dest.
             if (srcType.details.constraints.every((sourceConstraint) => {