@zzzen/pyright-internal 1.2.0-dev.20230910 → 1.2.0-dev.20230924

package/dist/analyzer/typeEvaluator.js

@@ -103,7 +103,6 @@ const nonSubscriptableBuiltinTypes = new Map([
 const typePromotions = new Map([
     ['builtins.float', ['builtins.int']],
     ['builtins.complex', ['builtins.float', 'builtins.int']],
-    ['builtins.bytes', ['builtins.bytearray', 'builtins.memoryview']],
 ]);
 // How many levels deep should we attempt to infer return
 // types based on call-site argument types? The deeper we go,
@@ -294,8 +293,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
-    function setTypeForNode(node, type = types_1.UnknownType.create(), flags = 0 /* None */) {
-        writeTypeCache(node, { type }, flags);
+    function setTypeResultForNode(node, typeResult, flags = 0 /* None */) {
+        writeTypeCache(node, typeResult, flags);
     }
     function setAsymmetricDescriptorAssignment(node) {
         if (isSpeculativeModeInUse(/* node */ undefined)) {
@@ -399,6 +398,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             evaluateTypesForExpressionInContext(node);
         });
     }
+    function getTypeResultForDecorator(node) {
+        return evaluateTypeForSubnode(node, () => {
+            evaluateTypesForExpressionInContext(node.expression);
+        });
+    }
     // Reads the type of the node from the cache.
     function getCachedType(node) {
         return readTypeCache(node, 0 /* None */);
@@ -2321,6 +2325,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
+    // If the type includes promotion types, expand these to their constituent types.
+    function expandPromotionTypes(node, type) {
+        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            if (!(0, types_1.isClass)(subtype) || !subtype.includePromotions) {
+                return subtype;
+            }
+            const typesToCombine = [types_1.ClassType.cloneForPromotionType(subtype, /* includePromotions */ false)];
+            const promotionTypeNames = typePromotions.get(subtype.details.fullName);
+            if (promotionTypeNames) {
+                for (const promotionTypeName of promotionTypeNames) {
+                    const nameSplit = promotionTypeName.split('.');
+                    let promotionSubtype = getBuiltInType(node, nameSplit[nameSplit.length - 1]);
+                    if (promotionSubtype && (0, types_1.isInstantiableClass)(promotionSubtype)) {
+                        promotionSubtype = types_1.ClassType.cloneForPromotionType(promotionSubtype, 
+                        /* includePromotions */ false);
+                        if ((0, types_1.isClassInstance)(subtype)) {
+                            promotionSubtype = types_1.ClassType.cloneAsInstance(promotionSubtype);
+                        }
+                        promotionSubtype = (0, typeUtils_1.addConditionToType)(promotionSubtype, subtype.condition);
+                        typesToCombine.push(promotionSubtype);
+                    }
+                }
+            }
+            return (0, types_1.combineTypes)(typesToCombine);
+        });
+    }
     // Replaces all of the top-level TypeVars (as opposed to TypeVars
     // used as type arguments in other types) with their concrete form.
     // If conditionFilter is specified and the TypeVar is a constrained
@@ -3405,7 +3435,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isNotRequired = false;
         // If the base type was incomplete and unbound, don't proceed
         // because false positive errors will be generated.
-        if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseTypeResult.type)) {
+        if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseType)) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
         // Handle the special case where the expression is an actual
@@ -3429,6 +3459,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isParamSpec)(baseType) && baseType.paramSpecAccess) {
             baseType = makeTopLevelTypeVarsConcrete(baseType);
         }
+        // Do union expansion for promotion types.
+        baseType = expandPromotionTypes(node, baseType);
         switch (baseType.category) {
             case 2 /* Any */:
             case 1 /* Unknown */:
@@ -5184,7 +5216,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeArgs.push(getTypeArgTypeResult(item, index));
             });
             // Set the node's type so it isn't reevaluated later.
-            setTypeForNode(node.items[0].valueExpression, types_1.UnknownType.create());
+            setTypeResultForNode(node.items[0].valueExpression, { type: types_1.UnknownType.create() });
         }
         else {
             node.items.forEach((arg, index) => {
@@ -5228,7 +5260,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 node,
             };
             // Set the node's type so it isn't reevaluated later.
-            setTypeForNode(node, types_1.UnknownType.create());
+            setTypeResultForNode(node, { type: types_1.UnknownType.create() });
         }
         else if (node.nodeType === 15 /* Dictionary */ && supportsDictExpression) {
             const inlinedTypeDict = typedDictClassType && (0, types_1.isInstantiableClass)(typedDictClassType)
@@ -6104,6 +6136,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateOverloadedFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         let filteredMatchResults = [];
         let contextFreeArgTypes;
+        let isTypeIncomplete = !!typeResult.isIncomplete;
         // Start by evaluating the types of the arguments without any expected
         // type. Also, filter the list of overloads based on the number of
         // positional and named arguments that are present. We do all of this
@@ -6117,6 +6150,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // intended behavior according to PEP 484.
                 const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
                 if (!matchResults.argumentErrors) {
+                    if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType) {
+                        const returnType = getFunctionEffectiveReturnType(matchResults.overload);
+                        if (!assignType(inferenceContext.expectedType, returnType, 
+                        /* diag */ undefined, 
+                        /* destTypeVarContext */ undefined, 
+                        /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+                            matchResults.relevance += -0.5;
+                        }
+                    }
                     filteredMatchResults.push(matchResults);
                 }
                 overloadIndex++;
@@ -6144,7 +6186,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
             }
-            return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
+            return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
         }
         // Create a helper function that evaluates the overload that best
         // matches the arg/param lists.
@@ -6170,7 +6212,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return evaluateUsingBestMatchingOverload(/* skipUnknownArgCheck */ false);
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
-        let isTypeIncomplete = !!typeResult.isIncomplete;
         while (true) {
             const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
             if (callResult.isTypeIncomplete) {
@@ -6216,7 +6257,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             result.returnType = types_1.UnknownType.create();
             return { ...result, argumentErrors: true };
         }
-        return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
+        return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
     }
     // Replaces each item in the expandedArgTypes with n items where n is
     // the number of subtypes in a union. The contextFreeArgTypes parameter
@@ -6900,14 +6941,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // all positional parameters specified in the Concatenate must be
                 // filled explicitly.
                 if (typeResult.type.details.paramSpec && paramIndex < positionParamLimitIndex) {
-                    if (!isDiagnosticSuppressedForNode(errorNode)) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                            ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                            : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                                expected: positionParamLimitIndex,
-                            }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                    if ((0, types_1.isTypeVar)(argTypeResult.type) && argTypeResult.type.paramSpecAccess === 'args') {
+                        if (!isDiagnosticSuppressedForNode(errorNode)) {
+                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                                ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                                : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                    expected: positionParamLimitIndex,
+                                }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                        }
+                        reportedArgError = true;
                     }
-                    reportedArgError = true;
                 }
                 const argType = argTypeResult.type;
                 if (isParamVariadic && (0, types_1.isUnpackedVariadicTypeVar)(argType)) {
@@ -7193,17 +7236,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             reportedArgError = true;
                         }
                     }
-                    else if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'kwargs') {
+                    else if (typeResult.type.details.paramSpec &&
+                        (0, parameterUtils_1.isParamSpecKwargsArgument)(typeResult.type.details.paramSpec, argType)) {
                         unpackedDictionaryArgType = types_1.AnyType.create();
-                        if (typeResult.type.details.paramSpec) {
-                            validateArgTypeParams.push({
-                                paramCategory: 2 /* KwargsDict */,
-                                paramType: typeResult.type.details.paramSpec,
-                                requiresTypeVarMatching: false,
-                                argument: argList[argIndex],
-                                errorNode: argList[argIndex].valueExpression || errorNode,
-                            });
-                        }
+                        validateArgTypeParams.push({
+                            paramCategory: 2 /* KwargsDict */,
+                            paramType: typeResult.type.details.paramSpec,
+                            requiresTypeVarMatching: false,
+                            argument: argList[argIndex],
+                            argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
+                            errorNode: argList[argIndex].valueExpression || errorNode,
+                        });
                     }
                     else {
                         const strObjType = getBuiltInObject(errorNode, 'str');
@@ -7331,20 +7374,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
-                        // Handle the case where a *args: P.args is passed as an argument to
-                        // a function that accepts a ParamSpec.
+                        // Handle the case where a *args: P.args (or *args: Any) is passed as an
+                        // argument to a function that accepts a ParamSpec.
                         if (typeResult.type.details.paramSpec) {
                             const argTypeResult = getTypeOfArgument(argList[argIndex]);
                             const argType = argTypeResult.type;
                             if (argTypeResult.isIncomplete) {
                                 isTypeIncomplete = true;
                             }
-                            if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'args') {
+                            if ((0, parameterUtils_1.isParamSpecArgsArgument)(typeResult.type.details.paramSpec, argType)) {
                                 validateArgTypeParams.push({
                                     paramCategory: 1 /* ArgsList */,
                                     paramType: typeResult.type.details.paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
+                                    argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
                                     errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
                                 });
                             }
@@ -7764,12 +7808,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (type.details.paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* UnpackedList */) {
-                    if ((0, types_1.isParamSpec)(argResult.argType) && argResult.argType.paramSpecAccess === 'args') {
+                    if ((0, parameterUtils_1.isParamSpecArgsArgument)(type.details.paramSpec, argResult.argType)) {
                         sawParamSpecArgs = true;
                     }
                 }
                 if (argParam.argument.argumentCategory === 2 /* UnpackedDictionary */) {
-                    if ((0, types_1.isParamSpec)(argResult.argType) && argResult.argType.paramSpecAccess === 'kwargs') {
+                    if ((0, parameterUtils_1.isParamSpecKwargsArgument)(type.details.paramSpec, argResult.argType)) {
                         sawParamSpecKwargs = true;
                     }
                 }
@@ -10685,6 +10729,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return (0, typeUtils_1.convertToInstance)(typeVar);
         });
+        const typeAliasScopeId = ParseTreeUtils.getScopeIdForNode(name);
         // Validate the default types for all type parameters.
         typeParameters.forEach((typeParam, index) => {
             var _a;
@@ -10692,7 +10737,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (typeParamNodes && index < typeParamNodes.length) {
                 bestErrorNode = (_a = typeParamNodes[index].defaultExpression) !== null && _a !== void 0 ? _a : typeParamNodes[index].name;
             }
-            validateTypeParameterDefault(bestErrorNode, typeParam, typeParameters.slice(0, index));
+            validateTypeParameterDefault(bestErrorNode, typeParam, typeParameters.slice(0, index), typeAliasScopeId);
         });
         // Verify that we have at most one variadic type variable.
         const variadics = typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
@@ -10702,7 +10747,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), errorNode);
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        const typeAliasScopeId = ParseTreeUtils.getScopeIdForNode(name);
         const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* Class */);
         if (boundTypeVars.length > 0) {
             addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
@@ -11137,6 +11181,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined, ParseTreeUtils.getDocString(node.suite.statements));
         classType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        // Is this a special type that supports type promotions according to PEP 484?
+        if (typePromotions.has(classType.details.fullName)) {
+            classType.includePromotions = true;
+        }
         // Some classes refer to themselves within type arguments used within
         // base classes. We'll register the partially-constructed class type
         // to allow these to be resolved.
@@ -11244,14 +11292,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (types_1.ClassType.isBuiltIn(argType, 'TypedDict') || types_1.ClassType.isTypedDictClass(argType)) {
                                 classType.details.flags |= 128 /* TypedDictClass */;
                             }
-                            else if (types_1.ClassType.isTypedDictClass(classType) && !types_1.ClassType.isTypedDictClass(argType)) {
-                                // Exempt Generic from this test. As of Python 3.11, generic TypedDict
-                                // classes are supported.
-                                if (!(0, types_1.isInstantiableClass)(argType) || !types_1.ClassType.isBuiltIn(argType, 'Generic')) {
-                                    // TypedDict classes must derive only from other TypedDict classes.
-                                    addError(localize_1.Localizer.Diagnostic.typedDictBaseClass(), arg);
-                                }
-                            }
                             // Validate that the class isn't deriving from itself, creating a
                             // circular dependency.
                             if ((0, typeUtils_1.derivesFromClassRecursive)(argType, classType, /* ignoreUnknown */ true)) {
@@ -11412,7 +11452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeParamNode = node.typeParameters.parameters[index];
                     bestErrorNode = (_a = typeParamNode.defaultExpression) !== null && _a !== void 0 ? _a : typeParamNode.name;
                 }
-                validateTypeParameterDefault(bestErrorNode, typeParam, classType.details.typeParameters.slice(0, index));
+                validateTypeParameterDefault(bestErrorNode, typeParam, classType.details.typeParameters.slice(0, index), classType.details.typeVarScopeId);
             });
             if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
                 addError(localize_1.Localizer.Diagnostic.methodOrdering(), node.name);
@@ -11548,6 +11588,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             registerDeferredClassCompletion(node, /* dependsUpon */ undefined);
             // Synthesize TypedDict methods.
             if (types_1.ClassType.isTypedDictClass(classType)) {
+                // TypedDict classes must derive only from other TypedDict classes.
+                let foundInvalidBaseClass = false;
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                classType.details.baseClasses.forEach((baseClass) => {
+                    if ((0, types_1.isClass)(baseClass) &&
+                        !types_1.ClassType.isTypedDictClass(baseClass) &&
+                        !types_1.ClassType.isBuiltIn(baseClass, ['_TypedDict', 'Generic'])) {
+                        foundInvalidBaseClass = true;
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictBaseClass().format({ type: baseClass.details.name }));
+                    }
+                });
+                if (foundInvalidBaseClass) {
+                    addError(localize_1.Localizer.Diagnostic.typedDictBaseClass() + diag.getString(), node.name);
+                }
                 (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
             }
             // Synthesize dataclass methods.
@@ -11564,7 +11618,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 let skipSynthesizeHash = false;
                 const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* SkipBaseClasses */);
-                if (hashSymbol) {
+                // If there is a hash symbol defined in the class (i.e. one that we didn't
+                // synthesize above), then we shouldn't synthesize a new one for the dataclass.
+                if (hashSymbol && !hashSymbol.symbol.getSynthesizedType()) {
                     skipSynthesizeHash = true;
                 }
                 (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
@@ -11614,11 +11670,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // type parameter. If so, validates that it is in the list of "live" type
     // parameters and updates the scope of the type parameter referred to in the
     // default type expression.
-    function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams) {
+    function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams, scopeId) {
         if (!typeParam.details.defaultType &&
             !typeParam.details.isSynthesized &&
             !typeParam.details.isSynthesizedSelf) {
-            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType);
+            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType && param.scopeId === scopeId);
             if (typeVarWithDefault) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarWithoutDefault().format({
                     name: typeParam.details.name,
@@ -12311,7 +12367,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeParamNode = node.typeParameters.parameters[index];
                 bestErrorNode = (_a = typeParamNode.defaultExpression) !== null && _a !== void 0 ? _a : typeParamNode.name;
             }
-            validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index));
+            validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index), functionType.details.typeVarScopeId);
         });
         // Clear the "partially evaluated" flag to indicate that the functionType
         // is fully evaluated.
@@ -14680,25 +14736,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (resolvedDecl.type === 8 /* Alias */) {
             // Build a module type that corresponds to the declaration and
             // its associated loader actions.
-            let moduleName = resolvedDecl.moduleName;
-            if (decl.type === 8 /* Alias */) {
-                if (decl.symbolName) {
-                    moduleName += '.' + decl.symbolName;
-                }
-                // If the module name is relative to the current file, use that
-                // file's module name as a reference.
-                if (moduleName.startsWith('.')) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(decl.node);
-                    const nameParts = fileInfo.moduleName.split('.');
-                    moduleName = moduleName.substr(1);
-                    while (moduleName.startsWith('.') && nameParts.length > 0) {
-                        moduleName = moduleName.substr(1);
-                        nameParts.pop();
-                    }
-                    moduleName = nameParts.join('.') + '.' + moduleName;
-                }
-            }
-            const moduleType = types_1.ModuleType.create(moduleName, resolvedDecl.path);
+            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.path);
             if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
                 return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
             }
@@ -15528,11 +15566,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return true;
         }
         // Handle special-case type promotions.
-        const promotionList = typePromotions.get(destType.details.fullName);
-        if (promotionList &&
-            promotionList.some((srcName) => srcType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && srcName === mroClass.details.fullName))) {
-            if ((flags & 1 /* EnforceInvariance */) === 0) {
-                return true;
+        if (destType.includePromotions) {
+            const promotionList = typePromotions.get(destType.details.fullName);
+            if (promotionList &&
+                promotionList.some((srcName) => srcType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && srcName === mroClass.details.fullName))) {
+                if ((flags & 1 /* EnforceInvariance */) === 0) {
+                    return true;
+                }
             }
         }
         // Is it a structural type (i.e. a protocol)? If so, we need to
@@ -16312,7 +16352,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Handle LiteralString special form.
                 if (types_1.ClassType.isBuiltIn(destType, 'LiteralString')) {
                     if (types_1.ClassType.isBuiltIn(concreteSrcType, 'str') && concreteSrcType.literalValue !== undefined) {
-                        return true;
+                        return (flags & 1 /* EnforceInvariance */) === 0;
                     }
                     else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString')) {
                         return true;
@@ -16320,7 +16360,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
                     strClassType &&
-                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    (0, types_1.isInstantiableClass)(strClassType) &&
+                    (flags & 1 /* EnforceInvariance */) === 0) {
                     concreteSrcType = types_1.ClassType.cloneAsInstance(strClassType);
                 }
                 if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
@@ -16572,7 +16613,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // If we have no src subtypes remaining but not all dest types have been subsumed
                     // by other dest types, then the types are not compatible if we're enforcing invariance.
                     if (remainingSrcSubtypes.length === 0) {
-                        return remainingDestSubtypes.every((destSubtype) => isTypeSubsumedByOtherType(destSubtype, destType.subtypes, 
+                        return remainingDestSubtypes.every((destSubtype) => isTypeSubsumedByOtherType(destSubtype, destType, 
                         /* allowAnyToSubsume */ true, recursionCount));
                     }
                 }
@@ -16629,7 +16670,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                 // Determine if the current subtype is subsumed by another subtype
                 // in the same union. If so, we can ignore this.
-                const isSubtypeSubsumed = isTypeSubsumedByOtherType(subtype, srcType.subtypes, 
+                const isSubtypeSubsumed = isTypeSubsumedByOtherType(subtype, srcType, 
                 /* allowAnyToSubsume */ false, recursionCount);
                 // Try again with a concrete version of the subtype.
                 if (!isSubtypeSubsumed &&
@@ -16645,9 +16686,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return true;
     }
     // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) one
-    // of the other types in a list.
-    function isTypeSubsumedByOtherType(type, otherTypes, allowAnyToSubsume, recursionCount = 0) {
+    // of the other type.
+    function isTypeSubsumedByOtherType(type, otherType, allowAnyToSubsume, recursionCount = 0) {
         const concreteType = makeTopLevelTypeVarsConcrete(type);
+        const otherTypes = (0, types_1.isUnion)(otherType) ? otherType.subtypes : [otherType];
         for (const otherType of otherTypes) {
             if ((0, types_1.isTypeSame)(otherType, type)) {
                 continue;
@@ -17373,6 +17415,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     !srcParamSpec ||
                     !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true })) {
                     const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.details.flags | 64 /* SynthesizedMethod */, effectiveSrcType.details.docString);
+                    remainingFunction.details.deprecatedMessage = effectiveSrcType.details.deprecatedMessage;
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
                     remainingFunction.details.constructorTypeVarScopeId =
                         effectiveSrcType.details.constructorTypeVarScopeId;
@@ -18379,6 +18422,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         runWithCancellationToken,
         getType,
         getTypeResult,
+        getTypeResultForDecorator,
         getCachedType,
         getTypeOfExpression,
         getTypeOfAnnotation,
@@ -18402,7 +18446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         validateInitSubclassArgs,
         isAfterNodeReachable,
         isNodeReachable,
-        isAsymmetricDescriptorAssignment: isAsymmetricAccessorAssignment,
+        isAsymmetricAccessorAssignment,
         suppressDiagnostics,
         getDeclarationsForStringNode,
         getDeclarationsForNameNode,
@@ -18414,8 +18458,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getGetterTypeFromProperty,
         getTypeOfArgument,
         markNamesAccessed,
+        expandPromotionTypes,
         makeTopLevelTypeVarsConcrete,
         mapSubtypesExpandTypeVars,
+        isTypeSubsumedByOtherType,
         lookUpSymbolRecursive,
         getDeclaredTypeOfSymbol,
         getEffectiveTypeOfSymbol,
@@ -18468,7 +18514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         disposeEvaluator,
         useSpeculativeMode,
         isSpeculativeModeInUse,
-        setTypeForNode,
+        setTypeResultForNode,
         checkForCancellation,
         printControlFlowGraph,
         printTypeVarContext,