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

package/dist/analyzer/typeEvaluator.js

@@ -103,6 +103,7 @@ 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,
@@ -180,6 +181,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let noneType;
     let objectType;
     let typeClassType;
+    let awaitableProtocolType;
     let functionObj;
     let tupleClassType;
     let boolClassType;
@@ -391,6 +393,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        if (type) {
+            type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
+        }
         return type;
     }
     function getTypeResult(node) {
@@ -460,6 +465,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             dictClassType = getBuiltInType(node, 'dict');
             typedDictClassType = getTypingType(node, 'TypedDict');
             typedDictPrivateClassType = getTypingType(node, '_TypedDict');
+            awaitableProtocolType = getTypingType(node, 'Awaitable');
             mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
             if (!mappingType) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
@@ -658,6 +664,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (expectingInstantiable) {
             validateTypeIsInstantiable(typeResult, flags, node);
         }
+        // Should we disable type promotions for bytes?
+        if ((0, types_1.isInstantiableClass)(typeResult.type) &&
+            typeResult.type.includePromotions &&
+            !typeResult.type.includeSubclasses &&
+            types_1.ClassType.isBuiltIn(typeResult.type, 'bytes')) {
+            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.disableBytesTypePromotions) {
+                typeResult = {
+                    ...typeResult,
+                    type: types_1.ClassType.cloneRemoveTypePromotions(typeResult.type),
+                };
+            }
+        }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
         // If there was an expected type, make sure that the result type is compatible.
         if (inferenceContext &&
@@ -928,6 +946,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
                     isIncomplete,
                 };
+                if ((0, types_1.isClass)(typeResult.type) && typeResult.type.includePromotions) {
+                    typeResult.type = types_1.ClassType.cloneRemoveTypePromotions(typeResult.type);
+                }
             }
         }
         else {
@@ -1258,7 +1279,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 !types_1.ClassType.isSameGenericClass(metaclass, objectType)) {
                 memberInfo = getTypeOfClassMemberName(errorNode, metaclass, 
                 /* isAccessedThroughObject */ false, memberName, usage, 
-                /* diag */ undefined, memberAccessFlags | 2 /* AccessInstanceMembersOnly */, types_1.ClassType.cloneAsInstantiable(objectType));
+                /* diag */ undefined, memberAccessFlags |
+                    2 /* AccessInstanceMembersOnly */ |
+                    128 /* SkipAttributeAccessOverride */, types_1.ClassType.cloneAsInstantiable(objectType));
             }
         }
         if (memberInfo) {
@@ -1267,6 +1290,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
+                memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
             };
         }
         return undefined;
@@ -1294,7 +1318,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !types_1.ClassType.isBuiltIn(metaclass, 'type') &&
             !types_1.ClassType.isSameGenericClass(metaclass, classType)) {
             const metaclassMemberInfo = getTypeOfClassMemberName(errorNode, metaclass, 
-            /* isAccessedThroughObject */ false, memberName, usage, metaclassDiag, memberAccessFlags, classType);
+            /* isAccessedThroughObject */ false, memberName, usage, metaclassDiag, memberAccessFlags | 128 /* SkipAttributeAccessOverride */, classType);
             if (metaclassMemberInfo && (0, typeUtils_1.isDescriptorInstance)(metaclassMemberInfo.type)) {
                 considerMetaclassOnly = true;
             }
@@ -1318,6 +1342,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
+                memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
             };
         }
         // Determine whether to use the class or metaclass diagnostic addendum.
@@ -1611,31 +1636,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // (object that provides an __await__ that returns a generator object).
     // If errorNode is undefined, no errors are reported.
     function getTypeOfAwaitable(type, errorNode) {
+        if (!awaitableProtocolType ||
+            !(0, types_1.isInstantiableClass)(awaitableProtocolType) ||
+            awaitableProtocolType.details.typeParameters.length !== 1) {
+            return types_1.UnknownType.create();
+        }
+        const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(awaitableProtocolType);
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
             }
+            const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
             if ((0, types_1.isClassInstance)(subtype)) {
-                const awaitReturnType = getSpecializedReturnType(subtype, '__await__', [], errorNode);
-                if (awaitReturnType) {
-                    if ((0, types_1.isAnyOrUnknown)(awaitReturnType)) {
-                        return awaitReturnType;
-                    }
-                    if ((0, types_1.isClassInstance)(awaitReturnType)) {
-                        const iterReturnType = getSpecializedReturnType(awaitReturnType, '__iter__', [], errorNode);
-                        if (iterReturnType) {
-                            const generatorReturnType = getReturnTypeFromGenerator(awaitReturnType);
-                            if (generatorReturnType) {
-                                return generatorReturnType;
-                            }
-                        }
+                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(awaitableProtocolObj));
+                if (assignType(awaitableProtocolObj, subtype, diag, typeVarContext)) {
+                    const specializedType = (0, typeUtils_1.applySolvedTypeVars)(awaitableProtocolObj, typeVarContext);
+                    if ((0, types_1.isClass)(specializedType) &&
+                        specializedType.typeArguments &&
+                        specializedType.typeArguments.length > 0) {
+                        return specializedType.typeArguments[0];
                     }
                 }
             }
             if (errorNode) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotAwaitable().format({ type: printType(subtype) }), errorNode);
+                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotAwaitable().format({ type: printType(subtype) }) + (diag === null || diag === void 0 ? void 0 : diag.getString()), errorNode);
             }
             return types_1.UnknownType.create();
         });
@@ -2150,8 +2176,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (setTypeResult.isAsymmetricAccessor) {
             setAsymmetricDescriptorAssignment(target);
         }
-        writeTypeCache(target.memberName, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
-        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
+        const resultToCache = {
+            type,
+            isIncomplete: isTypeIncomplete,
+            memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
+        };
+        writeTypeCache(target.memberName, resultToCache, 0 /* None */);
+        writeTypeCache(target, resultToCache, 0 /* None */);
     }
     function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
         var _a;
@@ -2326,20 +2357,22 @@ 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) {
+    function expandPromotionTypes(node, type, excludeBytes = false) {
         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)];
+            if (excludeBytes && types_1.ClassType.isBuiltIn(subtype, 'bytes')) {
+                return subtype;
+            }
+            const typesToCombine = [types_1.ClassType.cloneRemoveTypePromotions(subtype)];
             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);
+                        promotionSubtype = types_1.ClassType.cloneRemoveTypePromotions(promotionSubtype);
                         if ((0, types_1.isClassInstance)(subtype)) {
                             promotionSubtype = types_1.ClassType.cloneAsInstance(promotionSubtype);
                         }
@@ -2562,6 +2595,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             inferTypeParameterVarianceForClass(type);
             let typeWasTransformed = false;
             const filteredTypeArgs = type.typeArguments.map((typeArg, index) => {
+                if (index > type.details.typeParameters.length) {
+                    return typeArg;
+                }
                 const variance = types_1.TypeVarType.getVariance(type.details.typeParameters[index]);
                 if (variance !== 3 /* Covariant */) {
                     return typeArg;
@@ -2756,9 +2792,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             case 35 /* MemberAccess */: {
                 const baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* MemberAccessBaseDefaults */);
-                const memberType = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
-                writeTypeCache(node.memberName, { type: memberType.type }, 0 /* None */);
-                writeTypeCache(node, { type: memberType.type }, 0 /* None */);
+                const delAccessResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
+                const resultToCache = {
+                    type: delAccessResult.type,
+                    memberAccessDeprecationInfo: delAccessResult.memberAccessDeprecationInfo,
+                };
+                writeTypeCache(node.memberName, resultToCache, 0 /* None */);
+                writeTypeCache(node, resultToCache, 0 /* None */);
                 break;
             }
             case 24 /* Index */: {
@@ -2795,22 +2835,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             fileInfo.accessedSymbolSet.add(symbol.id);
         }
     }
-    function getReturnTypeFromGenerator(type) {
-        if ((0, types_1.isAnyOrUnknown)(type)) {
-            return type;
-        }
-        if ((0, types_1.isClassInstance)(type)) {
-            // Is this a Generator? If so, return the third
-            // type argument, which is the await response type.
-            if (types_1.ClassType.isBuiltIn(type, 'Generator')) {
-                const typeArgs = type.typeArguments;
-                if (typeArgs && typeArgs.length >= 3) {
-                    return typeArgs[2];
-                }
-            }
-        }
-        return undefined;
-    }
     function getSpecializedReturnType(objType, memberName, argList, errorNode, bindToClass) {
         const classMember = (0, typeUtils_1.lookUpObjectMember)(objType, memberName, 8 /* SkipInstanceVariables */);
         if (!classMember) {
@@ -3433,6 +3457,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isAsymmetricAccessor;
         const isRequired = false;
         const isNotRequired = false;
+        let memberAccessDeprecationInfo;
         // 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)(baseType)) {
@@ -3459,8 +3484,6 @@ 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 */:
@@ -3522,6 +3545,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
                         isAsymmetricAccessor = true;
                     }
+                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+                        memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                    }
                 }
                 else {
                     // Handle the special case of 'name' and 'value' members within an enum.
@@ -3540,6 +3566,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
                         isAsymmetricAccessor = true;
                     }
+                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+                        memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                    }
                 }
                 break;
             }
@@ -3642,6 +3671,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (typeResult.isIncomplete) {
                             isIncomplete = true;
                         }
+                        if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+                            memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                        }
                         return typeResult.type;
                     }
                 });
@@ -3741,7 +3773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* ignoreEmptyContainers */ false);
             }
         }
-        return { type, isIncomplete, isAsymmetricAccessor, isRequired, isNotRequired };
+        return { type, isIncomplete, isAsymmetricAccessor, isRequired, isNotRequired, memberAccessDeprecationInfo };
     }
     function getTypeOfClassMemberName(errorNode, classType, isAccessedThroughObject, memberName, usage, diag, flags, bindToType) {
         var _a, _b;
@@ -3899,6 +3931,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isClassVar: memberInfo.isClassVar,
                 classType: memberInfo.classType,
                 isAsymmetricAccessor: descriptorResult.isAsymmetricAccessor,
+                memberAccessDeprecationInfo: descriptorResult === null || descriptorResult === void 0 ? void 0 : descriptorResult.memberAccessDeprecationInfo,
             };
         }
         // No attribute of that name was found. If this is a member access
@@ -3928,6 +3961,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const treatConstructorAsClassMember = (flags & 32 /* TreatConstructorAsClassMethod */) !== 0;
         let isTypeValid = true;
         let isAsymmetricAccessor = false;
+        let memberAccessDeprecationInfo;
         type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             var _a, _b, _c;
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
@@ -4085,6 +4119,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     }
                                     const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
                                     /* skipUnknownArgCheck */ true);
+                                    if (callResult.overloadsUsedForCall &&
+                                        callResult.overloadsUsedForCall.length >= 1) {
+                                        const overloadUsed = callResult.overloadsUsedForCall[0];
+                                        if (overloadUsed.details.deprecatedMessage) {
+                                            memberAccessDeprecationInfo = {
+                                                deprecationMessage: overloadUsed.details.deprecatedMessage,
+                                                accessType: lookupClass && types_1.ClassType.isPropertyClass(lookupClass)
+                                                    ? 'property'
+                                                    : 'descriptor',
+                                                accessMethod: usage.method,
+                                            };
+                                        }
+                                    }
                                     if (callResult.argumentErrors) {
                                         if (usage.method === 'set') {
                                             if (usage.setType &&
@@ -4230,7 +4277,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!isTypeValid) {
             return undefined;
         }
-        return { type, isAsymmetricAccessor };
+        return { type, isAsymmetricAccessor, memberAccessDeprecationInfo };
     }
     function isAsymmetricDescriptorClass(classType) {
         var _a;
@@ -5745,7 +5792,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.arguments.length > 2) {
             addError(localize_1.Localizer.Diagnostic.superCallArgCount(), node.arguments[2]);
         }
-        const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node);
         const enclosingClass = enclosingFunction
             ? ParseTreeUtils.getEnclosingClass(enclosingFunction, /* stopAtFunction */ true)
             : undefined;
@@ -6150,9 +6197,11 @@ 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 there is an expected return type, see if it's potentially compatible
+                    // with this overload's return type. If not, we'll de-emphasize this overload.
                     if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType) {
                         const returnType = getFunctionEffectiveReturnType(matchResults.overload);
-                        if (!assignType(inferenceContext.expectedType, returnType, 
+                        if (!assignType((0, typeUtils_1.replaceTypeVarsWithAny)(inferenceContext.expectedType), (0, typeUtils_1.replaceTypeVarsWithAny)(returnType), 
                         /* diag */ undefined, 
                         /* destTypeVarContext */ undefined, 
                         /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
@@ -6190,7 +6239,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Create a helper function that evaluates the overload that best
         // matches the arg/param lists.
-        function evaluateUsingBestMatchingOverload(skipUnknownArgCheck) {
+        function evaluateUsingBestMatchingOverload(skipUnknownArgCheck, emitNoOverloadFoundError) {
             // Find the match with the smallest argument match score. If there
             // are more than one with the same score, use the one with the
             // largest index. Later overloads tend to be more general.
@@ -6200,6 +6249,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return current.argumentMatchScore < previous.argumentMatchScore ? current : previous;
             });
+            // If there is more than one filtered match, report that no match
+            // was possible and emit a diagnostic that provides the most likely.
+            if (emitNoOverloadFoundError) {
+                const functionName = bestMatch.overload.details.name || '<anonymous function>';
+                const diagnostic = addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }), errorNode);
+                const overrideDecl = bestMatch.overload.details.declaration;
+                if (diagnostic && overrideDecl) {
+                    diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.path, overrideDecl.range);
+                }
+            }
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
             effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(bestMatch.overload));
             effectiveTypeVarContext.unlock();
@@ -6209,7 +6268,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // use the normal type matching mechanism because it is faster and
         // will provide a clearer error message.
         if (filteredMatchResults.length === 1) {
-            return evaluateUsingBestMatchingOverload(/* skipUnknownArgCheck */ false);
+            return evaluateUsingBestMatchingOverload(
+            /* skipUnknownArgCheck */ false, 
+            /* emitNoOverloadFoundError */ false);
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
         while (true) {
@@ -6251,7 +6312,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // in speculative mode because it's very expensive, and we're going to
         // suppress the diagnostic anyway.
         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-            const result = evaluateUsingBestMatchingOverload(/* skipUnknownArgCheck */ true);
+            const result = evaluateUsingBestMatchingOverload(
+            /* skipUnknownArgCheck */ true, 
+            /* emitNoOverloadFoundError */ true);
             // Replace the result with an unknown type since we don't know
             // what overload should have been used.
             result.returnType = types_1.UnknownType.create();
@@ -7822,7 +7885,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let paramSpecTypeVarContext = [];
         // Handle the assignment of additional arguments that map to a param spec.
         if (matchResults.paramSpecArgList && matchResults.paramSpecTarget) {
-            const paramSpecArgResult = validateFunctionArgumentsForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext, typeCondition);
+            const paramSpecArgResult = validateFunctionArgumentsForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext, signatureTracker);
             if (paramSpecArgResult.argumentErrors) {
                 argumentErrors = true;
                 argumentMatchScore += 1;
@@ -8030,18 +8093,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
-    function validateFunctionArgumentsForParamSpec(errorNode, argList, paramSpec, destTypeVarContext, conditionFilter) {
+    function validateFunctionArgumentsForParamSpec(errorNode, argList, paramSpec, destTypeVarContext, signatureTracker) {
         const signatureContexts = destTypeVarContext.getSignatureContexts();
         // Handle the common case where there is only one signature context.
         if (signatureContexts.length === 1) {
-            return validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, signatureContexts[0], conditionFilter);
+            return validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, signatureContexts[0], signatureTracker);
         }
         const filteredSignatureContexts = [];
         const typeVarContexts = [];
         signatureContexts.forEach((context) => {
             // Use speculative mode to avoid emitting errors or caching types.
             useSpeculativeMode(errorNode, () => {
-                const paramSpecArgResult = validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, context, conditionFilter);
+                const paramSpecArgResult = validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, context, signatureTracker);
                 if (!paramSpecArgResult.argumentErrors) {
                     filteredSignatureContexts.push(context);
                 }
@@ -8053,163 +8116,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             destTypeVarContext.copySignatureContexts(filteredSignatureContexts);
         }
         // Evaluate non-speculatively to produce a final result and cache types.
-        const paramSpecArgResult = validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, filteredSignatureContexts.length > 0 ? filteredSignatureContexts[0] : signatureContexts[0], conditionFilter);
+        const paramSpecArgResult = validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, filteredSignatureContexts.length > 0 ? filteredSignatureContexts[0] : signatureContexts[0], signatureTracker);
         return { argumentErrors: paramSpecArgResult.argumentErrors, typeVarContexts };
     }
-    function validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext, conditionFilter) {
+    function validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext, signatureTracker) {
         var _a;
         const paramSpecType = typeVarContext.getParamSpecType(paramSpec);
         if (!paramSpecType) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotBound().format({ type: printType(paramSpec) }), ((_a = argList[0]) === null || _a === void 0 ? void 0 : _a.valueExpression) || errorNode);
             return { argumentErrors: true, typeVarContexts: [undefined] };
         }
-        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: paramSpecType }, 0);
         const srcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(paramSpecType));
-        let reportedArgError = false;
-        let sawUnpackedListArgument = false;
-        let sawUnpackedDictArgument = false;
-        let paramMap = new Map();
-        // We'll use two passes in case there are type variables that depend
-        // on later arguments.
-        const passCount = 2;
-        for (let i = 0; i < passCount; i++) {
-            // Unless we're on the last pass, use speculative mode to suppress
-            // any diagnostics.
-            useSpeculativeMode(i < passCount - 1 ? errorNode : undefined, () => {
-                // Build a map of all named parameters.
-                paramMap = new Map();
-                const paramSpecParams = paramSpecType.details.parameters;
-                paramSpecParams.forEach((param) => {
-                    if (param.name) {
-                        paramMap.set(param.name, param);
-                    }
-                });
-                let positionalIndex = 0;
-                let positionalIndexLimit = paramSpecParams.findIndex((paramInfo) => paramInfo.category !== 0 /* Simple */);
-                if (positionalIndexLimit < 0) {
-                    positionalIndexLimit = paramSpecParams.length;
-                }
-                const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* ArgsList */);
-                const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* KwargsDict */);
-                const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
-                const nestedArgList = [];
-                argList.forEach((arg) => {
-                    var _a;
-                    if (arg.argumentCategory === 0 /* Simple */) {
-                        let paramType;
-                        if (arg.name) {
-                            const paramInfo = paramMap.get(arg.name.value);
-                            if (paramInfo) {
-                                paramType = paramInfo.type;
-                                paramMap.delete(arg.name.value);
-                            }
-                            else if (kwargsParam) {
-                                paramType = kwargsParam.type;
-                            }
-                            else {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), arg.name || errorNode);
-                                reportedArgError = true;
-                            }
-                        }
-                        else {
-                            if (positionalIndex < positionalIndexLimit) {
-                                const paramInfo = paramSpecParams[positionalIndex];
-                                paramType = paramInfo.type;
-                                if (paramInfo.name) {
-                                    paramMap.delete(paramInfo.name);
-                                }
-                            }
-                            else if (argsParam) {
-                                paramType = argsParam.type;
-                            }
-                            else if (paramSpecType.details.paramSpec) {
-                                nestedArgList.push(arg);
-                            }
-                            else {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, paramSpecParams.length === 1
-                                    ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                                    : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                                        expected: paramSpecParams.length,
-                                    }), (_a = arg.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
-                                reportedArgError = true;
-                            }
-                            positionalIndex++;
-                        }
-                        if (paramType) {
-                            const argResult = validateArgType({
-                                paramCategory: 0 /* Simple */,
-                                paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes, 
-                                /* usageOffset */ undefined),
-                                requiresTypeVarMatching: false,
-                                argument: arg,
-                                errorNode: arg.valueExpression || errorNode,
-                            }, srcTypeVarContext, signatureTracker, 
-                            /* functionType */ undefined, { conditionFilter });
-                            if (!argResult.isCompatible) {
-                                reportedArgError = true;
-                            }
-                        }
-                    }
-                    else if (arg.argumentCategory === 1 /* UnpackedList */) {
-                        sawUnpackedListArgument = true;
-                        // See if there is an *args parameter.
-                        const argsParam = paramSpecParams.find((param) => param.category === 1 /* ArgsList */ && param.name);
-                        if (argsParam && paramMap.has(argsParam.name)) {
-                            // TODO - validate args type
-                            paramMap.delete(argsParam.name);
-                        }
-                    }
-                    else {
-                        sawUnpackedDictArgument = true;
-                        (0, debug_1.assert)(arg.argumentCategory === 2 /* UnpackedDictionary */);
-                        // See if there is an *kwargs parameter.
-                        const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* KwargsDict */);
-                        if (kwargsParam && paramMap.has(kwargsParam.name)) {
-                            // TODO - validate kwargs type
-                            paramMap.delete(kwargsParam.name);
-                        }
-                    }
-                });
-                // Handle recursive ParamSpecs.
-                if (paramSpecType.details.paramSpec) {
-                    const boundTypeForParamSpec = srcTypeVarContext
-                        .getPrimarySignature()
-                        .getParamSpecType(paramSpecType.details.paramSpec);
-                    if (boundTypeForParamSpec) {
-                        const paramSpecArgResult = validateFunctionArgumentsForParamSpec(errorNode, nestedArgList, paramSpecType.details.paramSpec, srcTypeVarContext, conditionFilter);
-                        if (paramSpecArgResult.argumentErrors) {
-                            reportedArgError = true;
-                        }
-                    }
+        if (matchResults.argumentErrors) {
+            // Evaluate types of all args. This will ensure that referenced symbols are
+            // not reported as unaccessed.
+            argList.forEach((arg) => {
+                if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
+                    getTypeOfExpression(arg.valueExpression);
                 }
             });
+            return { argumentErrors: true, typeVarContexts: [srcTypeVarContext] };
         }
-        // Report any missing parameters.
-        if (!reportedArgError) {
-            let unassignedParams = Array.from(paramMap.keys());
-            // Parameters that have defaults can be left unspecified.
-            unassignedParams = unassignedParams.filter((name) => {
-                const paramInfo = paramMap.get(name);
-                return paramInfo.category === 0 /* Simple */ && !paramInfo.hasDefault;
-            });
-            if (unassignedParams.length > 0 &&
-                !paramSpecType.details.paramSpec &&
-                !sawUnpackedListArgument &&
-                !sawUnpackedDictArgument) {
-                const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
-                    ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
-                    : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
-                reportedArgError = true;
-            }
-        }
-        if (!reportedArgError) {
-            (0, typeUtils_1.applySourceContextTypeVarsToSignature)(typeVarContext, srcTypeVarContext);
-        }
-        return {
-            argumentErrors: reportedArgError,
-            typeVarContexts: [reportedArgError ? srcTypeVarContext : undefined],
-        };
+        const result = validateFunctionArgumentTypes(errorNode, matchResults, srcTypeVarContext, signatureTracker);
+        return { argumentErrors: !!result.argumentErrors, typeVarContexts: [srcTypeVarContext] };
     }
     function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, options) {
         var _a;
@@ -9160,20 +9090,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return undefined;
         }
-        const builtInDict = getBuiltInObject(node, 'dict');
-        if (!(0, types_1.isClassInstance)(builtInDict)) {
-            return undefined;
-        }
-        const dictTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInDict));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
-            return undefined;
+        let expectedKeyType;
+        let expectedValueType;
+        if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
+            expectedKeyType = inferenceContext.expectedType;
+            expectedValueType = inferenceContext.expectedType;
         }
-        const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
-        if (!specializedDict.typeArguments || specializedDict.typeArguments.length !== 2) {
-            return undefined;
+        else {
+            const builtInDict = getBuiltInObject(node, 'dict');
+            if (!(0, types_1.isClassInstance)(builtInDict)) {
+                return undefined;
+            }
+            const dictTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInDict));
+            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+                return undefined;
+            }
+            const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
+            if (!specializedDict.typeArguments || specializedDict.typeArguments.length !== 2) {
+                return undefined;
+            }
+            expectedKeyType = specializedDict.typeArguments[0];
+            expectedValueType = specializedDict.typeArguments[1];
         }
-        const expectedKeyType = specializedDict.typeArguments[0];
-        const expectedValueType = specializedDict.typeArguments[1];
         // Dict and MutableMapping types have invariant value types, so they
         // cannot be narrowed further. Other super-types like Mapping, Collection,
         // and Iterable use covariant value types, so they can be narrowed.
@@ -9451,22 +9389,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         let typeErrors = false;
         const verifyHashable = node.nodeType === 45 /* Set */;
-        if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
-            return undefined;
-        }
-        const builtInListOrSet = getBuiltInObject(node, builtInClassName);
-        if (!(0, types_1.isClassInstance)(builtInListOrSet)) {
-            return undefined;
-        }
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInListOrSet));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
-            return undefined;
+        let expectedEntryType;
+        if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
+            expectedEntryType = inferenceContext.expectedType;
         }
-        const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInListOrSet), typeVarContext);
-        if (!specializedListOrSet.typeArguments || specializedListOrSet.typeArguments.length !== 1) {
-            return undefined;
+        else {
+            if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
+                return undefined;
+            }
+            const builtInListOrSet = getBuiltInObject(node, builtInClassName);
+            if (!(0, types_1.isClassInstance)(builtInListOrSet)) {
+                return undefined;
+            }
+            const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInListOrSet));
+            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+                return undefined;
+            }
+            const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInListOrSet), typeVarContext);
+            if (!specializedListOrSet.typeArguments || specializedListOrSet.typeArguments.length !== 1) {
+                return undefined;
+            }
+            expectedEntryType = specializedListOrSet.typeArguments[0];
         }
-        const expectedEntryType = specializedListOrSet.typeArguments[0];
         const entryTypes = [];
         const expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
         node.entries.forEach((entry) => {
@@ -10022,6 +9966,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         functionType.details.declaredReturnType = types_1.UnknownType.create();
         functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
         if (typeArgs && typeArgs.length > 0) {
+            functionType.isCallableWithTypeArgs = true;
             if (typeArgs[0].typeList) {
                 const typeList = typeArgs[0].typeList;
                 let sawUnpacked = false;
@@ -10169,7 +10114,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function cloneBuiltinObjectWithLiteral(node, builtInName, value) {
         const type = getBuiltInObject(node, builtInName);
         if ((0, types_1.isClassInstance)(type)) {
-            return types_1.ClassType.cloneWithLiteral(type, value);
+            return types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneRemoveTypePromotions(type), value);
         }
         return types_1.UnknownType.create();
     }
@@ -10332,12 +10277,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
         if (enclosingFunction) {
-            const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, enclosingFunction, 
+            const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
             /* isInClass */ true);
             const isInnerFunction = !!ParseTreeUtils.getEnclosingFunction(enclosingFunction);
             if (!isInnerFunction) {
                 // Check for static methods.
-                if (functionFlags & 4 /* StaticMethod */) {
+                if (functionInfo.flags & 4 /* StaticMethod */) {
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeContext(), errorNode);
                     return types_1.UnknownType.create();
                 }
@@ -11768,7 +11713,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         node.parameters.forEach((param) => {
             var _a;
             const paramSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
-            (0, debug_1.assert)(paramSymbol);
+            if (!paramSymbol) {
+                // This can happen if the code is unreachable.
+                return;
+            }
             const typeOfParam = (_a = getDeclaredTypeOfSymbol(paramSymbol, param.name)) === null || _a === void 0 ? void 0 : _a.type;
             if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
                 return;
@@ -12030,6 +11978,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // See if there are any overloads provided by previous function declarations.
         if ((0, types_1.isFunction)(decoratedType)) {
+            decoratedType.details.deprecatedMessage = functionType.details.deprecatedMessage;
             if (types_1.FunctionType.isOverloaded(decoratedType)) {
                 // Mark all the parameters as accessed.
                 node.parameters.forEach((param) => {
@@ -12063,7 +12012,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (containingClassNode) {
             containingClassType = (_a = getTypeOfClass(containingClassNode)) === null || _a === void 0 ? void 0 : _a.classType;
         }
-        let functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, node, !!containingClassNode);
+        const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, node, !!containingClassNode);
+        let functionFlags = functionInfo.flags;
         if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
             functionFlags |= 16 /* Generator */;
         }
@@ -12078,6 +12028,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const functionType = types_1.FunctionType.createInstance(node.name.value, getFunctionFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, functionFlags | 131072 /* PartiallyEvaluated */, ParseTreeUtils.getDocString(node.suite.statements));
         functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        functionType.details.deprecatedMessage = functionInfo.deprecationMessage;
         if (node.name.value === '__init__' || node.name.value === '__new__') {
             if (containingClassNode) {
                 functionType.details.constructorTypeVarScopeId = ParseTreeUtils.getScopeIdForNode(containingClassNode);
@@ -12197,7 +12148,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             let defaultValueType;
             if (param.defaultValue) {
-                defaultValueType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
+                // If this is a stub file, a protocol, an overload, or a class
+                // whose body is a placeholder implementation, treat a "...", as
+                // an "Any" value.
+                let treatEllipsisAsAny = fileInfo.isStubFile || ParseTreeUtils.isSuiteEmpty(node.suite);
+                if (containingClassType && types_1.ClassType.isProtocolClass(containingClassType)) {
+                    treatEllipsisAsAny = true;
+                }
+                if (types_1.FunctionType.isOverloaded(functionType) || types_1.FunctionType.isAbstractMethod(functionType)) {
+                    treatEllipsisAsAny = true;
+                }
+                defaultValueType = getTypeOfExpression(param.defaultValue, treatEllipsisAsAny ? 1 /* ConvertEllipsisToAny */ : 0 /* None */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
             }
             if (annotatedType) {
                 // If there was both a type annotation and a default value, verify
@@ -13498,7 +13459,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // See if the function is a method in a child class. We may be able to
         // infer the type of the parameter from a method of the same name in
         // a parent class if it has an annotated type.
-        const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, functionNode, /* isInClass */ true);
+        const functionFlags = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, functionNode, 
+        /* isInClass */ true).flags;
         const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
         writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* None */);
     }
@@ -15620,6 +15582,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             sourceType: srcErrorTypeText,
             destType: destErrorTypeText,
         }));
+        // Tell the user about the disableBytesTypePromotions if that is involved.
+        if (types_1.ClassType.isBuiltIn(destType, 'bytes')) {
+            const promotions = typePromotions.get(destType.details.fullName);
+            if (promotions && promotions.some((name) => name === srcType.details.fullName)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.bytesTypePromotions());
+            }
+        }
         return false;
     }
     // This function is used to validate or infer the variance of type
@@ -15968,6 +15937,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (includeDiagAddendum) {
                                 childDiag.addAddendum(assignmentDiag);
                             }
+                            if (isCompatible && types_1.ClassType.isSameGenericClass(destType, srcType)) {
+                                // Add additional notes to help the user if this is a common type mismatch.
+                                if (types_1.ClassType.isBuiltIn(destType, 'dict') && srcArgIndex === 1) {
+                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionDict());
+                                }
+                                else if (types_1.ClassType.isBuiltIn(destType, 'list')) {
+                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionList());
+                                }
+                            }
                         }
                         else {
                             diag.addAddendum(assignmentDiag);
@@ -18093,7 +18071,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let isAbstract;
                         const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
                         if (decl && decl.type === 5 /* Function */) {
-                            const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, decl.node, true);
+                            const functionFlags = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, decl.node, true).flags;
                             isAbstract = !!(functionFlags & 8 /* AbstractMethod */);
                         }
                         else {