@zzzen/pyright-internal 1.2.0-dev.20240602 → 1.2.0-dev.20240616

package/dist/analyzer/typeEvaluator.js

@@ -466,7 +466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             functionClass = getBuiltInType(node, 'function');
             unionTypeClass = getTypesType(node, 'UnionType');
             if (unionTypeClass && (0, types_1.isClass)(unionTypeClass)) {
-                unionTypeClass.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
+                unionTypeClass.details.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
             }
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
@@ -487,7 +487,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Wire up the `Any` class to the special-form version of our internal AnyType.
             if (objectClass && (0, types_1.isInstantiableClass)(objectClass) && typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
-                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */ | -2147483648 /* ClassTypeFlags.SpecialFormClass */, 
+                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */ | 8388608 /* ClassTypeFlags.SpecialFormClass */, 
                 /* typeSourceId */ -1, 
                 /* declaredMetaclass */ undefined, 
                 /* effectiveMetaclass */ typeClass);
@@ -679,7 +679,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             case 3 /* ParseNodeType.Assignment */: {
                 typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext, signatureTracker);
-                assignTypeToExpression(node.leftExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
+                assignTypeToExpression(node.leftExpression, typeResult, node.rightExpression, 
                 /* ignoreEmptyContainers */ true, 
                 /* allowAssignmentToFinalVar */ true);
                 break;
@@ -689,8 +689,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     addError(localize_1.LocMessage.walrusNotAllowed(), node);
                 }
                 typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext, signatureTracker);
-                assignTypeToExpression(node.name, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
-                /* ignoreEmptyContainers */ true);
+                assignTypeToExpression(node.name, typeResult, node.rightExpression, /* ignoreEmptyContainers */ true);
                 break;
             }
             case 60 /* ParseNodeType.Yield */: {
@@ -741,6 +740,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (expectingInstantiable) {
             validateTypeIsInstantiable(typeResult, flags, node);
         }
+        // If this is a PEP 695 type alias, remove the special form so the type
+        // printer prints it as its aliased type rather than TypeAliasType.
+        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+            if (typeResult.type.specialForm && types_1.ClassType.isBuiltIn(typeResult.type.specialForm, 'TypeAliasType')) {
+                typeResult.type = types_1.TypeBase.cloneAsSpecialForm(typeResult.type, undefined);
+            }
+        }
         return typeResult;
     }
     // Reports the case where a function or class has been decorated with
@@ -1271,9 +1277,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
                 if (concreteSubtype.literalValue !== undefined) {
+                    let isLiteralFalsy;
+                    if (concreteSubtype.literalValue instanceof types_1.EnumLiteral) {
+                        isLiteralFalsy = !canBeTruthy(concreteSubtype);
+                    }
+                    else {
+                        isLiteralFalsy = !concreteSubtype.literalValue;
+                    }
                     // If the object is already definitely falsy, it's fine to
                     // include, otherwise it should be removed.
-                    return !concreteSubtype.literalValue ? subtype : undefined;
+                    return isLiteralFalsy ? subtype : undefined;
                 }
                 // If the object is a bool, make it "false", since
                 // "true" is a truthy value.
@@ -1307,9 +1320,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
                 if (concreteSubtype.literalValue !== undefined) {
+                    let isLiteralTruthy;
+                    if (concreteSubtype.literalValue instanceof types_1.EnumLiteral) {
+                        isLiteralTruthy = !canBeFalsy(concreteSubtype);
+                    }
+                    else {
+                        isLiteralTruthy = !!concreteSubtype.literalValue;
+                    }
                     // If the object is already definitely truthy, it's fine to
                     // include, otherwise it should be removed.
-                    return concreteSubtype.literalValue ? subtype : undefined;
+                    return isLiteralTruthy ? subtype : undefined;
                 }
                 // If the object is a bool, make it "true", since
                 // "false" is a falsy value.
@@ -1447,7 +1467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If this is a type[Any] or type[Unknown], allow any other members.
         if ((0, types_1.isClassInstance)(objectType) && types_1.ClassType.isBuiltIn(objectType, 'type') && objectType.includeSubclasses) {
-            if ((flags & 8 /* MemberAccessFlags.SkipTypeBaseClass */) === 0) {
+            if ((flags & (8 /* MemberAccessFlags.SkipTypeBaseClass */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */)) === 0) {
                 const typeArg = objectType.typeArguments && objectType.typeArguments.length >= 1
                     ? objectType.typeArguments[0]
                     : types_1.UnknownType.create();
@@ -2022,7 +2042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 errorRange = { start: 0, length: 0 };
             }
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            addDiagnosticForTextRange(fileInfo, fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), errorRange);
+            addDiagnosticForTextRange(fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), errorRange);
             return true;
         }
         return false;
@@ -2163,7 +2183,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return diagnostic;
     }
-    function addDiagnosticForTextRange(fileInfo, diagLevel, rule, message, range) {
+    function addDiagnosticForTextRange(fileInfo, rule, message, range) {
+        const diagLevel = fileInfo.diagnosticRuleSet[rule];
         if (diagLevel === 'none') {
             return undefined;
         }
@@ -2184,7 +2205,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeExpectedClass().format({ type: printType(type) }) + diag.getString(), node);
     }
-    function assignTypeToNameNode(nameNode, type, isTypeIncomplete, ignoreEmptyContainers, srcExpression, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
+    function assignTypeToNameNode(nameNode, typeResult, ignoreEmptyContainers, srcExpression, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
         var _a, _b, _c;
         const nameValue = nameNode.value;
         const symbolWithScope = lookUpSymbolRecursive(nameNode, nameValue, /* honorCodeFlow */ false);
@@ -2211,18 +2232,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // We found an existing declared type. Make sure the type is assignable.
-        let destType = type;
+        let destType = typeResult.type;
         const isTypeAlias = !!declaredType && (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias');
         if (declaredType && !isTypeAlias) {
             let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            if (!assignType(declaredType, type, diagAddendum)) {
+            if (!assignType(declaredType, typeResult.type, diagAddendum)) {
                 // If there was an expected type mismatch, use that diagnostic
                 // addendum because it will be more informative.
                 if (expectedTypeDiagAddendum) {
                     diagAddendum = expectedTypeDiagAddendum;
                 }
-                if (!isTypeIncomplete) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
+                if (!typeResult.isIncomplete) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(typeResult.type, declaredType)) +
                         diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
                 }
                 // Replace the assigned type with the (unnarrowed) declared type.
@@ -2230,7 +2251,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else {
                 // Constrain the resulting type to match the declared type.
-                destType = narrowTypeBasedOnAssignment(nameNode, declaredType, type);
+                destType = narrowTypeBasedOnAssignment(nameNode, declaredType, typeResult).type;
             }
         }
         else {
@@ -2263,12 +2284,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name: nameValue }), nameNode);
             }
         }
-        if (!isTypeIncomplete) {
+        if (!typeResult.isIncomplete) {
             reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
         }
-        writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(nameNode, { type: destType, isIncomplete: typeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
     }
-    function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
+    function assignTypeToMemberAccessNode(target, typeResult, srcExpr, expectedTypeDiagAddendum) {
         var _a;
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
@@ -2281,14 +2302,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (classTypeResults && (0, types_1.isInstantiableClass)(classTypeResults.classType)) {
                     if ((0, types_1.isClassInstance)(baseType)) {
                         if (types_1.ClassType.isSameGenericClass(baseType, classTypeResults.classType)) {
-                            assignTypeToMemberVariable(target, type, isTypeIncomplete, 
-                            /* isInstanceMember */ true, srcExpr);
+                            assignTypeToMemberVariable(target, typeResult, /* isInstanceMember */ true, srcExpr);
                         }
                     }
                     else if ((0, types_1.isInstantiableClass)(baseType)) {
                         if (types_1.ClassType.isSameGenericClass(baseType, classTypeResults.classType)) {
-                            assignTypeToMemberVariable(target, type, isTypeIncomplete, 
-                            /* isInstanceMember */ false, srcExpr);
+                            assignTypeToMemberVariable(target, typeResult, /* isInstanceMember */ false, srcExpr);
                         }
                     }
                     // Assignments to instance or class variables through "self" or "cls" is not
@@ -2309,7 +2328,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const setTypeResult = getTypeOfMemberAccessWithBaseType(target, baseTypeResult, {
             method: 'set',
-            setType: { type, isIncomplete: isTypeIncomplete },
+            setType: typeResult,
             setErrorNode: srcExpr,
             setExpectedTypeDiag: expectedTypeDiagAddendum,
         }, 0 /* EvaluatorFlags.None */);
@@ -2317,14 +2336,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             setAsymmetricDescriptorAssignment(target);
         }
         const resultToCache = {
-            type: (_a = setTypeResult.narrowedTypeForSet) !== null && _a !== void 0 ? _a : type,
-            isIncomplete: isTypeIncomplete,
+            type: (_a = setTypeResult.narrowedTypeForSet) !== null && _a !== void 0 ? _a : typeResult.type,
+            isIncomplete: typeResult.isIncomplete,
             memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
         };
         writeTypeCache(target.memberName, resultToCache, 0 /* EvaluatorFlags.None */);
         writeTypeCache(target, resultToCache, 0 /* EvaluatorFlags.None */);
     }
-    function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
+    function assignTypeToMemberVariable(node, typeResult, isInstanceMember, srcExprNode) {
         var _a;
         const memberName = node.memberName.value;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -2394,20 +2413,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             // The class variable is accessed in this case.
                             setSymbolAccessed(fileInfo, memberInfo.symbol, node.memberName);
                             const memberType = getTypeOfMember(memberInfo);
-                            srcType = (0, types_1.combineTypes)([srcType, memberType]);
+                            typeResult = { ...typeResult, type: (0, types_1.combineTypes)([typeResult.type, memberType]) };
                         }
                     }
                 }
             }
             // Look up the member info again, now that we've potentially updated it.
             memberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
-            if (!memberInfo && srcExprNode && !isTypeIncomplete) {
-                reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.memberName, srcType, node, 
+            if (!memberInfo && srcExprNode && !typeResult.isIncomplete) {
+                reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.memberName, typeResult.type, node, 
                 /* ignoreEmptyContainers */ true);
             }
         }
     }
-    function assignTypeToTupleOrListNode(target, type, isTypeIncomplete, srcExpr) {
+    function assignTypeToTupleOrListNode(target, typeResult, srcExpr) {
         const targetExpressions = target.nodeType === 34 /* ParseNodeType.List */ ? target.entries : target.expressions;
         // Initialize the array of target types, one for each target.
         const targetTypes = new Array(targetExpressions.length);
@@ -2418,9 +2437,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Do any of the targets use an unpack operator? If so, it will consume all of the
         // entries at that location.
         const unpackIndex = targetExpressions.findIndex((expr) => expr.nodeType === 56 /* ParseNodeType.Unpack */);
-        type = makeTopLevelTypeVarsConcrete(type);
+        typeResult = { ...typeResult, type: makeTopLevelTypeVarsConcrete(typeResult.type) };
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+        (0, typeUtils_1.doForEachSubtype)(typeResult.type, (subtype) => {
             var _a, _b;
             // Is this subtype a tuple?
             const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
@@ -2475,7 +2494,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 // The assigned expression isn't a tuple, so it had better
                 // be some iterable type.
-                const iterableType = (_b = (_a = getTypeOfIterator({ type: subtype, isIncomplete: isTypeIncomplete }, /* isAsync */ false, srcExpr)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                const iterableType = (_b = (_a = getTypeOfIterator({ type: subtype, isIncomplete: typeResult.isIncomplete }, 
+                /* isAsync */ false, srcExpr)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 for (let index = 0; index < targetExpressions.length; index++) {
                     targetTypes[index].push((0, typeUtils_1.addConditionToType)(iterableType, (0, typeUtils_1.getTypeCondition)(subtype)));
                 }
@@ -2485,7 +2505,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, (target.nodeType === 34 /* ParseNodeType.List */
                 ? localize_1.LocMessage.listAssignmentMismatch()
                 : localize_1.LocMessage.tupleAssignmentMismatch()).format({
-                type: printType(type),
+                type: printType(typeResult.type),
             }) + diagAddendum.getString(), target);
         }
         // Assign the resulting types to the individual names in the tuple
@@ -2493,9 +2513,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         targetExpressions.forEach((expr, index) => {
             const typeList = targetTypes[index];
             const targetType = typeList.length === 0 ? types_1.UnknownType.create() : (0, types_1.combineTypes)(typeList);
-            assignTypeToExpression(expr, targetType, isTypeIncomplete, srcExpr, /* ignoreEmptyContainers */ true);
+            assignTypeToExpression(expr, { type: targetType, isIncomplete: typeResult.isIncomplete }, srcExpr, 
+            /* ignoreEmptyContainers */ true);
         });
-        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(target, typeResult, 0 /* EvaluatorFlags.None */);
     }
     // If the type includes promotion types, expand these to their constituent types.
     function expandPromotionTypes(node, type, excludeBytes = false) {
@@ -2546,11 +2567,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // If this is a function that contains only a ParamSpec (no additional
             // parameters), convert it to a concrete type of (*args: Any, **kwargs: Any).
-            if (makeParamSpecsConcrete &&
-                (0, types_1.isFunction)(subtype) &&
-                subtype.details.parameters.length === 0 &&
-                subtype.details.paramSpec) {
-                return types_1.FunctionType.cloneForParamSpec(subtype, (0, typeUtils_1.getUnknownTypeForCallable)());
+            if (makeParamSpecsConcrete && (0, types_1.isFunction)(subtype)) {
+                const convertedType = (0, typeUtils_1.convertParamSpecValueToType)(subtype);
+                if ((0, types_1.isParamSpec)(convertedType)) {
+                    return types_1.FunctionType.applyParamSpecValue(subtype, (0, typeUtils_1.getUnknownTypeForCallable)());
+                }
             }
             if ((0, types_1.isTypeVar)(subtype) && subtype.details.isVariadic) {
                 // If it's in a union, convert to type or object.
@@ -2719,9 +2740,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
         }
     }
-    function assignTypeToExpression(target, type, isTypeIncomplete, srcExpr, ignoreEmptyContainers = false, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
+    function assignTypeToExpression(target, typeResult, srcExpr, ignoreEmptyContainers = false, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
         // Is the source expression a TypeVar() call?
-        if ((0, types_1.isTypeVar)(type)) {
+        if ((0, types_1.isTypeVar)(typeResult.type)) {
             if (srcExpr && srcExpr.nodeType === 9 /* ParseNodeType.Call */) {
                 const callType = getTypeOfExpression(srcExpr.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) &&
@@ -2729,13 +2750,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         types_1.ClassType.isBuiltIn(callType, 'TypeVarTuple') ||
                         types_1.ClassType.isBuiltIn(callType, 'ParamSpec'))) {
                     const typeVarTarget = target.nodeType === 54 /* ParseNodeType.TypeAnnotation */ ? target.valueExpression : target;
-                    if (typeVarTarget.nodeType !== 38 /* ParseNodeType.Name */ || typeVarTarget.value !== type.details.name) {
-                        addError(type.details.isParamSpec
+                    if (typeVarTarget.nodeType !== 38 /* ParseNodeType.Name */ ||
+                        typeVarTarget.value !== typeResult.type.details.name) {
+                        addError(typeResult.type.details.isParamSpec
                             ? localize_1.LocMessage.paramSpecAssignedName().format({
-                                name: types_1.TypeVarType.getReadableName(type),
+                                name: types_1.TypeVarType.getReadableName(typeResult.type),
                             })
                             : localize_1.LocMessage.typeVarAssignedName().format({
-                                name: types_1.TypeVarType.getReadableName(type),
+                                name: types_1.TypeVarType.getReadableName(typeResult.type),
                             }), typeVarTarget);
                     }
                 }
@@ -2744,30 +2766,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If the type was partially unbound, an error will have already been logged.
         // Remove the unbound before assigning to the target expression so the unbound
         // error doesn't propagate.
-        type = (0, types_1.removeUnbound)(type);
+        if ((0, types_1.findSubtype)(typeResult.type, (subtype) => (0, types_1.isUnbound)(subtype))) {
+            typeResult = { ...typeResult, type: (0, types_1.removeUnbound)(typeResult.type) };
+        }
         switch (target.nodeType) {
             case 38 /* ParseNodeType.Name */: {
-                assignTypeToNameNode(target, type, isTypeIncomplete, ignoreEmptyContainers, srcExpr, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
+                assignTypeToNameNode(target, typeResult, ignoreEmptyContainers, srcExpr, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
                 break;
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum);
+                assignTypeToMemberAccessNode(target, typeResult, srcExpr, expectedTypeDiagAddendum);
                 break;
             }
             case 27 /* ParseNodeType.Index */: {
                 const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* EvaluatorFlags.IndexBaseDefaults */);
                 getTypeOfIndexWithBaseType(target, baseTypeResult, {
                     method: 'set',
-                    setType: { type, isIncomplete: isTypeIncomplete },
+                    setType: typeResult,
                     setErrorNode: srcExpr,
                     setExpectedTypeDiag: expectedTypeDiagAddendum,
                 }, 0 /* EvaluatorFlags.None */);
-                writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
+                writeTypeCache(target, typeResult, 0 /* EvaluatorFlags.None */);
                 break;
             }
             case 34 /* ParseNodeType.List */:
             case 52 /* ParseNodeType.Tuple */: {
-                assignTypeToTupleOrListNode(target, type, isTypeIncomplete, srcExpr);
+                assignTypeToTupleOrListNode(target, typeResult, srcExpr);
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
@@ -2782,23 +2806,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!isBareFinalOrClassVar) {
                     const isTypeAliasAnnotation = (0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias');
                     if (!isTypeAliasAnnotation) {
-                        if (assignType(annotationType, type)) {
+                        if (assignType(annotationType, typeResult.type)) {
                             // Don't attempt to narrow based on the annotated type if the type
                             // is a enum because the annotated type in an enum doesn't reflect
                             // the type of the symbol.
-                            if (!(0, types_1.isClassInstance)(type) || !types_1.ClassType.isEnumClass(type)) {
-                                type = narrowTypeBasedOnAssignment(target, annotationType, type);
+                            if (!(0, types_1.isClassInstance)(typeResult.type) || !types_1.ClassType.isEnumClass(typeResult.type)) {
+                                typeResult = narrowTypeBasedOnAssignment(target, annotationType, typeResult);
                             }
                         }
                     }
                 }
-                assignTypeToExpression(target.valueExpression, type, isTypeIncomplete, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
+                assignTypeToExpression(target.valueExpression, typeResult, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
                 break;
             }
             case 56 /* ParseNodeType.Unpack */: {
                 if (target.expression.nodeType === 38 /* ParseNodeType.Name */) {
-                    assignTypeToNameNode(target.expression, getBuiltInObject(target.expression, 'list', [type]), 
-                    /* isIncomplete */ false, ignoreEmptyContainers, srcExpr);
+                    assignTypeToNameNode(target.expression, {
+                        type: getBuiltInObject(target.expression, 'list', [typeResult.type]),
+                        isIncomplete: typeResult.isIncomplete,
+                    }, ignoreEmptyContainers, srcExpr);
                 }
                 break;
             }
@@ -4014,7 +4040,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // descriptor-based accesses.
                 narrowedTypeForSet = isDescriptorApplied
                     ? usage.setType.type
-                    : narrowTypeBasedOnAssignment(errorNode, type, usage.setType.type);
+                    : narrowTypeBasedOnAssignment(errorNode, type, usage.setType).type;
             }
             // Verify that the assigned type is compatible.
             if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
@@ -4030,7 +4056,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isDescriptorError = true;
             }
             if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
-                types_1.ClassType.isFrozenDataClass(memberInfo.classType) &&
+                types_1.ClassType.isDataClassFrozen(memberInfo.classType) &&
                 isAccessedThroughObject) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.dataClassFrozen().format({
                     name: printType(types_1.ClassType.cloneAsInstance(memberInfo.classType)),
@@ -4301,7 +4327,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If there's no declared return type on the getter, assume it's symmetric.
                 if (setterType.details.parameters.length >= 3 && getterType.details.declaredReturnType) {
                     const setterValueType = types_1.FunctionType.getEffectiveParameterType(setterType, 2);
-                    const getterReturnType = (_a = types_1.FunctionType.getSpecializedReturnType(getterType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+                    const getterReturnType = (_a = types_1.FunctionType.getEffectiveReturnType(getterType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                     if (!(0, types_1.isTypeSame)(setterValueType, getterReturnType)) {
                         isAsymmetric = true;
                     }
@@ -4333,7 +4359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If there's no declared return type on the getter, assume it's symmetric.
                 if (setterType.details.parameters.length >= 3 && getterType.details.declaredReturnType) {
                     const setterValueType = types_1.FunctionType.getEffectiveParameterType(setterType, 2);
-                    const getterReturnType = (_a = types_1.FunctionType.getSpecializedReturnType(getterType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+                    const getterReturnType = (_a = types_1.FunctionType.getEffectiveReturnType(getterType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                     if (!(0, types_1.isTypeSame)(setterValueType, getterReturnType)) {
                         isAsymmetric = true;
                     }
@@ -4699,11 +4725,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (index === concatTypeArgs.length - 1) {
                                 types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
                                 if ((0, types_1.isParamSpec)(typeArg)) {
-                                    functionType.details.paramSpec = typeArg;
+                                    types_1.FunctionType.addParamSpecVariadics(functionType, typeArg);
                                 }
                                 else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
                                     types_1.FunctionType.addDefaultParameters(functionType);
-                                    functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+                                    functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
                                 }
                             }
                             else {
@@ -4720,7 +4746,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, typeUtils_1.isEllipsisType)(typeArgType)) {
-                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.GradualCallableForm */);
                     types_1.FunctionType.addDefaultParameters(functionType);
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
                 }
@@ -5628,7 +5654,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // the base type of this call is not the same as one of the tracked signatures.
         // This is important for nested generic calls (e.g. "foo(foo(x))").
         if (signatureTracker) {
-            baseTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(baseTypeResult.type, signatureTracker, node.leftExpression.start);
+            baseTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(baseTypeResult.type, signatureTracker, node.start);
         }
         if (!(0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === 'super') {
@@ -5822,24 +5848,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const type = typeResult.type;
         const exprString = ParseTreeUtils.printExpression(arg0Value);
         const typeString = printType(type, { expandTypeAlias: true });
-        if (expectedText !== undefined) {
-            if (expectedText !== typeString) {
-                addError(localize_1.LocMessage.revealTypeExpectedTextMismatch().format({
-                    expected: expectedText,
-                    received: typeString,
-                }), expectedTextNode !== null && expectedTextNode !== void 0 ? expectedTextNode : arg0Value);
+        if (!typeResult.isIncomplete) {
+            if (expectedText !== undefined) {
+                if (expectedText !== typeString) {
+                    addError(localize_1.LocMessage.revealTypeExpectedTextMismatch().format({
+                        expected: expectedText,
+                        received: typeString,
+                    }), expectedTextNode !== null && expectedTextNode !== void 0 ? expectedTextNode : arg0Value);
+                }
             }
-        }
-        if (expectedRevealType) {
-            if (!(0, types_1.isTypeSame)(expectedRevealType, type, { ignorePseudoGeneric: true })) {
-                const expectedRevealTypeText = printType(expectedRevealType);
-                addError(localize_1.LocMessage.revealTypeExpectedTypeMismatch().format({
-                    expected: expectedRevealTypeText,
-                    received: typeString,
-                }), expectedRevealTypeNode !== null && expectedRevealTypeNode !== void 0 ? expectedRevealTypeNode : arg0Value);
+            if (expectedRevealType) {
+                if (!(0, types_1.isTypeSame)(expectedRevealType, type, { ignorePseudoGeneric: true })) {
+                    const expectedRevealTypeText = printType(expectedRevealType);
+                    addError(localize_1.LocMessage.revealTypeExpectedTypeMismatch().format({
+                        expected: expectedRevealTypeText,
+                        received: typeString,
+                    }), expectedRevealTypeNode !== null && expectedRevealTypeNode !== void 0 ? expectedRevealTypeNode : arg0Value);
+                }
             }
+            addInformation(localize_1.LocAddendum.typeOfSymbol().format({ name: exprString, type: typeString }), node.arguments[0]);
         }
-        addInformation(localize_1.LocAddendum.typeOfSymbol().format({ name: exprString, type: typeString }), node.arguments[0]);
         return { type, isIncomplete: typeResult.isIncomplete };
     }
     function getTypeOfRevealLocals(node) {
@@ -6943,6 +6971,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isTypeVar)(unexpandedCallType)) {
             returnType = (0, typeUtils_1.convertToInstance)(unexpandedCallType);
         }
+        // If we instantiated the "deprecated" class, attach the deprecation
+        // message to the instance.
+        if (errorNode.nodeType === 9 /* ParseNodeType.Call */ &&
+            returnType &&
+            (0, types_1.isClassInstance)(returnType) &&
+            types_1.ClassType.isBuiltIn(returnType, 'deprecated')) {
+            returnType = types_1.ClassType.cloneForDeprecatedInstance(returnType, (0, decorators_1.getDeprecatedMessageFromCall)(errorNode));
+        }
         // If we instantiated a type, transform it into a class.
         // This can happen if someone directly instantiates a metaclass
         // deriving from type.
@@ -7074,6 +7110,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let reportedArgError = false;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         let isVariadicTypeVarFullyMatched = false;
+        const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(typeResult.type);
         // Expand any unpacked tuples in the arg list.
         argList = expandArgList(argList, signatureTracker);
         // Build a map of parameters by name.
@@ -7099,6 +7136,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let paramSpecArgList;
         let paramSpecTarget;
         let hasParamSpecArgsKwargs = false;
+        // Determine how many positional args are being passed before
+        // we see a keyword arg.
+        let positionalArgCount = argList.findIndex((arg) => arg.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */ || arg.name !== undefined);
+        if (positionalArgCount < 0) {
+            positionalArgCount = argList.length;
+        }
         if (varArgListParamIndex !== undefined && varArgDictParamIndex !== undefined) {
             (0, debug_1.assert)(paramDetails.params[varArgListParamIndex], 'varArgListParamIndex params entry is undefined');
             const varArgListParam = paramDetails.params[varArgListParamIndex].param;
@@ -7120,16 +7163,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     positionalOnlyLimitIndex = varArgListParamIndex;
+                    positionalArgCount = varArgListParamIndex;
+                    positionParamLimitIndex = varArgListParamIndex;
                 }
             }
         }
-        else if (typeResult.type.details.paramSpec) {
-            const paramSpecScopeId = typeResult.type.details.paramSpec.scopeId;
-            if ((_c = (0, typeUtils_1.getTypeVarScopeIds)(typeResult.type)) === null || _c === void 0 ? void 0 : _c.some((id) => id === paramSpecScopeId)) {
+        else if (paramSpec) {
+            if ((_c = (0, typeUtils_1.getTypeVarScopeIds)(typeResult.type)) === null || _c === void 0 ? void 0 : _c.some((id) => id === paramSpec.scopeId)) {
                 hasParamSpecArgsKwargs = true;
                 paramSpecArgList = [];
-                paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(typeResult.type.details.paramSpec, 
-                /* access */ undefined);
+                paramSpecTarget = paramSpec;
             }
         }
         // If there are keyword arguments present after a *args argument,
@@ -7159,12 +7202,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (positionParamLimitIndex < 0) {
             positionParamLimitIndex = paramDetails.params.length;
         }
-        // Determine how many positional args are being passed before
-        // we see a keyword arg.
-        let positionalArgCount = argList.findIndex((arg) => arg.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */ || arg.name !== undefined);
-        if (positionalArgCount < 0) {
-            positionalArgCount = argList.length;
-        }
         let validateArgTypeParams = [];
         let activeParam;
         function trySetActive(arg, param) {
@@ -7541,13 +7578,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             reportedArgError = true;
                         }
                     }
-                    else if (typeResult.type.details.paramSpec &&
-                        (0, parameterUtils_1.isParamSpecKwargsArgument)(typeResult.type.details.paramSpec, argType)) {
+                    else if (paramSpec && (0, parameterUtils_1.isParamSpecKwargsArgument)(paramSpec, argType)) {
                         unpackedDictionaryArgType = types_1.AnyType.create();
                         if (!paramSpecArgList) {
                             validateArgTypeParams.push({
                                 paramCategory: 2 /* ParameterCategory.KwargsDict */,
-                                paramType: typeResult.type.details.paramSpec,
+                                paramType: paramSpec,
                                 requiresTypeVarMatching: false,
                                 argument: argList[argIndex],
                                 argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
@@ -7685,17 +7721,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     else if (argList[argIndex].argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
                         // 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) {
+                        if (paramSpec) {
                             const argTypeResult = getTypeOfArgument(argList[argIndex], 
                             /* inferenceContext */ undefined, signatureTracker);
                             const argType = argTypeResult.type;
                             if (argTypeResult.isIncomplete) {
                                 isTypeIncomplete = true;
                             }
-                            if ((0, parameterUtils_1.isParamSpecArgsArgument)(typeResult.type.details.paramSpec, argType)) {
+                            if ((0, parameterUtils_1.isParamSpecArgsArgument)(paramSpec, argType)) {
                                 validateArgTypeParams.push({
                                     paramCategory: 1 /* ParameterCategory.ArgsList */,
-                                    paramType: typeResult.type.details.paramSpec,
+                                    paramType: paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
@@ -7904,7 +7940,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
             !type.details.declaredReturnType ||
-            !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
+            !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getEffectiveReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
             return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
@@ -7995,6 +8031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let specializedInitSelfType;
         let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
+        const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
         // Check for an attempt to invoke an unimplemented abstract method.
         if (type.boundToType && !type.boundToType.includeSubclasses && type.details.methodClass) {
             const abstractSymbolInfo = getAbstractSymbolInfo(type.details.methodClass, type.details.name);
@@ -8004,36 +8041,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
             }
         }
-        if (type.boundTypeVarScopeId) {
-            // If the function was bound to a class or object and was a constructor, a
-            // static method or a class method, it's possible that some of that class's
-            // type variables have not yet been solved. Add that class's TypeVar scope ID.
-            if (type.preBoundFlags !== undefined && type.boundToType && (0, typeUtils_1.requiresSpecialization)(type.boundToType)) {
-                if (type.preBoundFlags &
-                    (4 /* FunctionTypeFlags.StaticMethod */ | 2 /* FunctionTypeFlags.ClassMethod */ | 4 /* FunctionTypeFlags.StaticMethod */)) {
-                    typeVarContext.addSolveForScope(type.boundTypeVarScopeId);
-                }
-            }
-            // The type annotation for the "self" parameter in an __init__ method to
-            // can incluence the type being constructed.
-            if (type.details.name === '__init__' &&
-                type.strippedFirstParamType &&
-                type.boundToType &&
-                (0, types_1.isClassInstance)(type.strippedFirstParamType) &&
-                (0, types_1.isClassInstance)(type.boundToType) &&
-                types_1.ClassType.isSameGenericClass(type.strippedFirstParamType, type.boundToType) &&
-                type.strippedFirstParamType.typeArguments) {
-                const typeParams = type.strippedFirstParamType.details.typeParameters;
-                specializedInitSelfType = type.strippedFirstParamType;
-                type.strippedFirstParamType.typeArguments.forEach((typeArg, index) => {
-                    if (index < typeParams.length) {
-                        const typeParam = typeParams[index];
-                        if (!(0, types_1.isTypeSame)(typeParam, typeArg, { ignorePseudoGeneric: true })) {
-                            typeVarContext.setTypeVarType(typeParams[index], typeArg);
-                        }
+        // The type annotation for the "self" parameter in an __init__ method to
+        // can influence the type being constructed.
+        if (type.details.name === '__init__' &&
+            type.strippedFirstParamType &&
+            type.boundToType &&
+            (0, types_1.isClassInstance)(type.strippedFirstParamType) &&
+            (0, types_1.isClassInstance)(type.boundToType) &&
+            types_1.ClassType.isSameGenericClass(type.strippedFirstParamType, type.boundToType) &&
+            type.strippedFirstParamType.typeArguments) {
+            const typeParams = type.strippedFirstParamType.details.typeParameters;
+            specializedInitSelfType = type.strippedFirstParamType;
+            type.strippedFirstParamType.typeArguments.forEach((typeArg, index) => {
+                if (index < typeParams.length) {
+                    const typeParam = typeParams[index];
+                    if (!(0, types_1.isTypeSame)(typeParam, typeArg, { ignorePseudoGeneric: true })) {
+                        typeVarContext.setTypeVarType(typeParams[index], typeArg);
                     }
-                });
-            }
+                }
+            });
         }
         // Special-case a few built-in calls that are often used for
         // casting or checking for unknown types.
@@ -8124,14 +8150,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArgument)
                     : argResult.argType;
             }
-            if (type.details.paramSpec) {
+            if (paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
-                    if ((0, parameterUtils_1.isParamSpecArgsArgument)(type.details.paramSpec, argResult.argType)) {
+                    if ((0, parameterUtils_1.isParamSpecArgsArgument)(paramSpec, argResult.argType)) {
                         sawParamSpecArgs = true;
                     }
                 }
                 if (argParam.argument.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
-                    if ((0, parameterUtils_1.isParamSpecKwargsArgument)(type.details.paramSpec, argResult.argType)) {
+                    if ((0, parameterUtils_1.isParamSpecKwargsArgument)(paramSpec, argResult.argType)) {
                         sawParamSpecKwargs = true;
                     }
                 }
@@ -8147,10 +8173,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             paramSpecTypeVarContext = paramSpecArgResult.typeVarContexts;
         }
-        else if (type.details.paramSpec) {
+        else if (paramSpec) {
             if (!sawParamSpecArgs || !sawParamSpecKwargs) {
                 if (!isTypeIncomplete) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({ type: printType(type.details.paramSpec) }), errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({ type: printType(paramSpec) }), errorNode);
                 }
                 argumentErrors = true;
                 argumentMatchScore += 1;
@@ -8373,39 +8399,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
             return { argumentErrors: true, typeVarContexts: [srcTypeVarContext] };
         }
+        const functionParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(functionType);
+        const functionWithoutParamSpec = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(functionType);
         // Handle the recursive case where we're passing (*args: P.args, **kwargs: P.args)
         // a remaining function of type (*P).
-        if (functionType.details.paramSpec &&
-            functionType.details.parameters.length === 0 &&
-            (0, types_1.isTypeSame)(functionType.details.paramSpec, paramSpec)) {
+        if (functionParamSpec &&
+            functionWithoutParamSpec.details.parameters.length === 0 &&
+            (0, types_1.isTypeSame)(functionParamSpec, paramSpec)) {
             // If there are any arguments other than *args: P.args or **kwargs: P.kwargs,
             // report an error.
-            let sawArgs = false;
-            let sawKwargs = false;
+            let argsCount = 0;
+            let kwargsCount = 0;
             let argumentErrors = false;
             let argErrorNode;
             for (const arg of argList) {
                 const argType = (_a = getTypeOfArgument(arg, /* inferenceContext */ undefined, signatureTracker)) === null || _a === void 0 ? void 0 : _a.type;
-                const isArgTypeCompatible = argType && ((0, types_1.isTypeSame)(argType, paramSpec, { ignoreTypeFlags: true }) || (0, types_1.isAnyOrUnknown)(argType));
-                if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */ && !sawArgs && isArgTypeCompatible) {
-                    sawArgs = true;
+                if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
+                    if ((0, parameterUtils_1.isParamSpecArgsArgument)(paramSpec, argType)) {
+                        argsCount++;
+                    }
                 }
-                else if (arg.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */ &&
-                    !sawKwargs &&
-                    isArgTypeCompatible) {
-                    sawKwargs = true;
+                else if (arg.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
+                    if ((0, parameterUtils_1.isParamSpecKwargsArgument)(paramSpec, argType)) {
+                        kwargsCount++;
+                    }
                 }
                 else {
                     argErrorNode = argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : arg.valueExpression;
                     argumentErrors = true;
                 }
             }
-            if (!sawArgs || !sawKwargs) {
+            if (argsCount !== 1 || kwargsCount !== 1) {
                 argumentErrors = true;
             }
             if (argumentErrors) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({
-                    type: printType(functionType.details.paramSpec),
+                    type: printType(functionParamSpec),
                 }), argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : errorNode);
             }
             return { argumentErrors, typeVarContexts: [srcTypeVarContext] };
@@ -8438,7 +8467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // the solved TypeVars if the typeVarContext has more than one signature.
                 // This will expand the ParamSpec into an overload, which will cause problems.
                 const skipApplySolvedTypeVars = (0, types_1.isFunction)(argParam.paramType) &&
-                    !!argParam.paramType.details.paramSpec &&
+                    types_1.FunctionType.getParamSpecFromArgsKwargs(argParam.paramType) &&
                     typeVarContext.getSignatureContexts().length > 1;
                 if (!skipApplySolvedTypeVars) {
                     expectedType = (0, typeUtils_1.applySolvedTypeVars)(expectedType, typeVarContext, {
@@ -8957,7 +8986,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (node.nodeType === 21 /* ParseNodeType.Ellipsis */) {
             types_1.FunctionType.addDefaultParameters(functionType);
-            functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+            functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
             return functionType;
         }
         if (node.nodeType === 34 /* ParseNodeType.List */) {
@@ -8991,7 +9020,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return undefined;
             }
             if ((0, types_1.isParamSpec)(typeResult.type)) {
-                functionType.details.paramSpec = typeResult.type;
+                types_1.FunctionType.addParamSpecVariadics(functionType, typeResult.type);
                 return functionType;
             }
             if ((0, types_1.isClassInstance)(typeResult.type) &&
@@ -9166,7 +9195,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeLiteral(), argList[1].node || errorNode);
         }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
-        classFlags |= 8192 /* ClassTypeFlags.Final */ | 536870912 /* ClassTypeFlags.NewTypeClass */ | 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */;
+        classFlags |= 256 /* ClassTypeFlags.Final */ | 2097152 /* ClassTypeFlags.NewTypeClass */ | 4194304 /* ClassTypeFlags.ValidTypeAliasClass */;
         const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
         classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
@@ -9198,7 +9227,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
             types_1.FunctionType.addDefaultParameters(newType);
             newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
-            newType.details.constructorTypeVarScopeId = classType.details.typeVarScopeId;
+            newType.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
             types_1.ClassType.getSymbolTable(classType).set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
         }
         return classType;
@@ -9220,7 +9249,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.tupleTypeArguments === undefined) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), metaclass, arg1Type.details.effectiveMetaclass);
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 4194304 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), metaclass, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
             if ((0, typeUtils_1.isEffectivelyInstantiable)(specializedType)) {
@@ -9944,7 +9973,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (enclosingFunction) {
             const functionTypeInfo = getTypeOfFunction(enclosingFunction);
             if (functionTypeInfo) {
-                const returnType = types_1.FunctionType.getSpecializedReturnType(functionTypeInfo.functionType);
+                const returnType = types_1.FunctionType.getEffectiveReturnType(functionTypeInfo.functionType);
                 if (returnType) {
                     expectedYieldType = (0, typeUtils_1.getGeneratorYieldType)(returnType, !!enclosingFunction.isAsync);
                     const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(returnType);
@@ -10033,128 +10062,134 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* FunctionTypeFlags.PartiallyEvaluated */);
         functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
-        // Pre-cache the incomplete function type in case the evaluation of the
-        // lambda depends on itself.
-        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* EvaluatorFlags.None */);
-        // We assume for simplicity that the parameter signature of the lambda is
-        // the same as the expected type. If this isn't the case, we'll use
-        // object for any lambda parameters that don't match. We could make this
-        // more sophisticated in the future, but it becomes very complex to handle
-        // all of the permutations.
-        let sawParamMismatch = false;
-        node.parameters.forEach((param, index) => {
-            let paramType;
-            if (expectedParamDetails && !sawParamMismatch) {
-                if (index < expectedParamDetails.params.length) {
-                    const expectedParam = expectedParamDetails.params[index];
-                    // If the parameter category matches and both of the parameters are
-                    // either separators (/ or *) or not separators, copy the type
-                    // from the expected parameter.
-                    if (expectedParam.param.category === param.category && !param.name === !expectedParam.param.name) {
-                        paramType = expectedParam.type;
+        return (0, cancellationUtils_1.invalidateTypeCacheIfCanceled)(() => {
+            // Pre-cache the incomplete function type in case the evaluation of the
+            // lambda depends on itself.
+            writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* EvaluatorFlags.None */);
+            // We assume for simplicity that the parameter signature of the lambda is
+            // the same as the expected type. If this isn't the case, we'll use
+            // object for any lambda parameters that don't match. We could make this
+            // more sophisticated in the future, but it becomes very complex to handle
+            // all of the permutations.
+            let sawParamMismatch = false;
+            node.parameters.forEach((param, index) => {
+                let paramType;
+                if (expectedParamDetails && !sawParamMismatch) {
+                    if (index < expectedParamDetails.params.length) {
+                        const expectedParam = expectedParamDetails.params[index];
+                        // If the parameter category matches and both of the parameters are
+                        // either separators (/ or *) or not separators, copy the type
+                        // from the expected parameter.
+                        if (expectedParam.param.category === param.category &&
+                            !param.name === !expectedParam.param.name) {
+                            paramType = expectedParam.type;
+                        }
+                        else {
+                            sawParamMismatch = true;
+                        }
                     }
-                    else {
-                        sawParamMismatch = true;
+                    else if (param.defaultValue) {
+                        // If the lambda param has a default value but there is no associated
+                        // parameter in the expected type, assume that the default value is
+                        // being used to explicitly capture a value from an outer scope. Infer
+                        // its type from the default value expression.
+                        paramType = getTypeOfExpression(param.defaultValue, undefined, inferenceContext).type;
                     }
                 }
                 else if (param.defaultValue) {
-                    // If the lambda param has a default value but there is no associated
-                    // parameter in the expected type, assume that the default value is
-                    // being used to explicitly capture a value from an outer scope. Infer
-                    // its type from the default value expression.
-                    paramType = getTypeOfExpression(param.defaultValue, undefined, inferenceContext).type;
-                }
-            }
-            else if (param.defaultValue) {
-                // If there is no inference context but we have a default value,
-                // use the default value to infer the parameter's type.
-                paramType = inferParameterTypeFromDefaultValue(param.defaultValue);
-            }
-            if (param.name) {
-                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) }, 0 /* EvaluatorFlags.None */);
-            }
-            if (param.defaultValue) {
-                // Evaluate the default value if it's present.
-                getTypeOfExpression(param.defaultValue, 1 /* EvaluatorFlags.ConvertEllipsisToAny */);
-            }
-            // Determine whether we need to insert an implied position-only parameter.
-            // This is needed when a function's parameters are named using the old-style
-            // way of specifying position-only parameters.
-            if (index >= 0) {
-                let isImplicitPositionOnlyParam = false;
-                if (param.category === 0 /* ParameterCategory.Simple */ && param.name) {
-                    if ((0, symbolNameUtils_1.isPrivateName)(param.name.value)) {
-                        isImplicitPositionOnlyParam = true;
+                    // If there is no inference context but we have a default value,
+                    // use the default value to infer the parameter's type.
+                    paramType = inferParameterTypeFromDefaultValue(param.defaultValue);
+                }
+                if (param.name) {
+                    writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) }, 0 /* EvaluatorFlags.None */);
+                }
+                if (param.defaultValue) {
+                    // Evaluate the default value if it's present.
+                    getTypeOfExpression(param.defaultValue, 1 /* EvaluatorFlags.ConvertEllipsisToAny */);
+                }
+                // Determine whether we need to insert an implied position-only parameter.
+                // This is needed when a function's parameters are named using the old-style
+                // way of specifying position-only parameters.
+                if (index >= 0) {
+                    let isImplicitPositionOnlyParam = false;
+                    if (param.category === 0 /* ParameterCategory.Simple */ && param.name) {
+                        if ((0, symbolNameUtils_1.isPrivateName)(param.name.value)) {
+                            isImplicitPositionOnlyParam = true;
+                        }
+                    }
+                    else {
+                        paramsArePositionOnly = false;
+                    }
+                    if (paramsArePositionOnly &&
+                        !isImplicitPositionOnlyParam &&
+                        functionType.details.parameters.length > 0) {
+                        types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                    }
+                    if (!isImplicitPositionOnlyParam) {
+                        paramsArePositionOnly = false;
                     }
                 }
-                else {
-                    paramsArePositionOnly = false;
-                }
-                if (paramsArePositionOnly &&
-                    !isImplicitPositionOnlyParam &&
-                    functionType.details.parameters.length > 0) {
-                    types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                const functionParam = {
+                    category: param.category,
+                    name: param.name ? param.name.value : undefined,
+                    hasDefault: !!param.defaultValue,
+                    defaultValueExpression: param.defaultValue,
+                    hasDeclaredType: true,
+                    type: paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(),
+                };
+                types_1.FunctionType.addParameter(functionType, functionParam);
+            });
+            if (paramsArePositionOnly && functionType.details.parameters.length > 0) {
+                types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+            }
+            let typeErrors = false;
+            // If we're speculatively evaluating the lambda, create another speculative
+            // evaluation scope for the return expression and do not allow retention
+            // of the cached types.
+            // We need to set allowCacheRetention to false because we don't want to
+            // cache the type of the lambda return expression because it depends on
+            // the parameter types that we set above, and the speculative type cache
+            // doesn't know about that context.
+            useSpeculativeMode(forceSpeculative || isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
+                ? node.expression
+                : undefined, () => {
+                const returnTypeResult = getTypeOfExpression(node.expression, 
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
+                functionType.inferredReturnType = returnTypeResult.type;
+                if (returnTypeResult.isIncomplete) {
+                    isIncomplete = true;
                 }
-                if (!isImplicitPositionOnlyParam) {
-                    paramsArePositionOnly = false;
+                if (returnTypeResult.typeErrors) {
+                    typeErrors = true;
                 }
-            }
-            const functionParam = {
-                category: param.category,
-                name: param.name ? param.name.value : undefined,
-                hasDefault: !!param.defaultValue,
-                defaultValueExpression: param.defaultValue,
-                hasDeclaredType: true,
-                type: paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(),
-            };
-            types_1.FunctionType.addParameter(functionType, functionParam);
-        });
-        if (paramsArePositionOnly && functionType.details.parameters.length > 0) {
-            types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
-        }
-        let typeErrors = false;
-        // If we're speculatively evaluating the lambda, create another speculative
-        // evaluation scope for the return expression and do not allow retention
-        // of the cached types.
-        // We need to set allowCacheRetention to false because we don't want to
-        // cache the type of the lambda return expression because it depends on
-        // the parameter types that we set above, and the speculative type cache
-        // doesn't know about that context.
-        useSpeculativeMode(forceSpeculative || isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
-            ? node.expression
-            : undefined, () => {
-            const returnTypeResult = getTypeOfExpression(node.expression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
-            functionType.inferredReturnType = returnTypeResult.type;
-            if (returnTypeResult.isIncomplete) {
-                isIncomplete = true;
-            }
-            if (returnTypeResult.typeErrors) {
-                typeErrors = true;
-            }
-            else if (expectedReturnType) {
-                // If the expectedReturnType is generic, see if the actual return type
-                // provides types for some or all type variables.
-                if ((0, typeUtils_1.requiresSpecialization)(expectedReturnType)) {
-                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType));
-                    if (assignType(expectedReturnType, returnTypeResult.type, /* diag */ undefined, typeVarContext)) {
-                        functionType = (0, typeUtils_1.applySolvedTypeVars)(functionType, typeVarContext, {
-                            applyInScopePlaceholders: true,
-                        });
+                else if (expectedReturnType) {
+                    // If the expectedReturnType is generic, see if the actual return type
+                    // provides types for some or all type variables.
+                    if ((0, typeUtils_1.requiresSpecialization)(expectedReturnType)) {
+                        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType));
+                        if (assignType(expectedReturnType, returnTypeResult.type, 
+                        /* diag */ undefined, typeVarContext)) {
+                            functionType = (0, typeUtils_1.applySolvedTypeVars)(functionType, typeVarContext, {
+                                applyInScopePlaceholders: true,
+                            });
+                        }
                     }
                 }
+            }, {
+                dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
+                allowDiagnostics: !forceSpeculative &&
+                    !isDiagnosticSuppressedForNode(node) &&
+                    !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
+            });
+            // Mark the function type as no longer being evaluated.
+            functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
+            // Is the resulting function compatible with the expected type?
+            if (expectedType && !assignType(expectedType, functionType)) {
+                typeErrors = true;
             }
-        }, {
-            dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
-            allowDiagnostics: !forceSpeculative && !isDiagnosticSuppressedForNode(node) && !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
+            return { type: functionType, isIncomplete, typeErrors };
         });
-        // Mark the function type as no longer being evaluated.
-        functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
-        // Is the resulting function compatible with the expected type?
-        if (expectedType && !assignType(expectedType, functionType)) {
-            typeErrors = true;
-        }
-        return { type: functionType, isIncomplete, typeErrors };
     }
     function getTypeOfComprehension(node, flags, inferenceContext) {
         let isIncomplete = false;
@@ -10229,16 +10264,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const iterableType = stripLiteralValue(iterableTypeResult.type);
             const itemTypeResult = (_a = getTypeOfIterator({ type: iterableType, isIncomplete: iterableTypeResult.isIncomplete }, !!node.isAsync, node.iterableExpression)) !== null && _a !== void 0 ? _a : { type: types_1.UnknownType.create(), isIncomplete: iterableTypeResult.isIncomplete };
             const targetExpr = node.targetExpression;
-            assignTypeToExpression(targetExpr, itemTypeResult.type, !!itemTypeResult.isIncomplete, node.iterableExpression);
+            assignTypeToExpression(targetExpr, itemTypeResult, node.iterableExpression);
         }
         else {
             (0, debug_1.assert)(node.nodeType === 13 /* ParseNodeType.ComprehensionIf */);
             // Evaluate the test expression to validate it and mark symbols
-            // as referenced. Don't bother doing this if we're in speculative
-            // mode because it doesn't affect the element type.
-            if (!isSpeculativeModeInUse(node.testExpression)) {
-                getTypeOfExpression(node.testExpression);
-            }
+            // as referenced. This doesn't affect the type of the evaluated
+            // comprehension, but it is important for evaluating intermediate
+            // expressions such as assignment expressions that can affect other
+            // subexpressions.
+            getTypeOfExpression(node.testExpression);
         }
         return isIncomplete;
     }
@@ -10370,6 +10405,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // The second argument, if present, should specify the return type.
     function createCallableType(classType, typeArgs, errorNode) {
         const functionType = types_1.FunctionType.createInstantiable(0 /* FunctionTypeFlags.None */);
+        let paramSpec;
         functionType.specialForm = classType;
         functionType.details.declaredReturnType = types_1.UnknownType.create();
         functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
@@ -10424,10 +10460,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if ((0, typeUtils_1.isEllipsisType)(typeArgs[0].type)) {
                 types_1.FunctionType.addDefaultParameters(functionType);
-                functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+                functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
             }
             else if ((0, types_1.isParamSpec)(typeArgs[0].type)) {
-                functionType.details.paramSpec = typeArgs[0].type;
+                paramSpec = typeArgs[0].type;
             }
             else {
                 if ((0, types_1.isInstantiableClass)(typeArgs[0].type) && types_1.ClassType.isBuiltIn(typeArgs[0].type, 'Concatenate')) {
@@ -10437,11 +10473,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (index === concatTypeArgs.length - 1) {
                                 types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
                                 if ((0, types_1.isParamSpec)(typeArg)) {
-                                    functionType.details.paramSpec = typeArg;
+                                    paramSpec = typeArg;
                                 }
                                 else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
                                     types_1.FunctionType.addDefaultParameters(functionType);
-                                    functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+                                    functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
                                 }
                             }
                             else {
@@ -10477,7 +10513,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else {
             types_1.FunctionType.addDefaultParameters(functionType, /* useUnknown */ true);
-            functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+            functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+        }
+        if (paramSpec) {
+            types_1.FunctionType.addParamSpecVariadics(functionType, paramSpec);
         }
         return functionType;
     }
@@ -10866,8 +10905,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
     function createAnnotatedType(classType, errorNode, typeArgs) {
-        if (typeArgs && typeArgs.length < 2) {
-            addError(localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
+        if (typeArgs) {
+            if (typeArgs.length < 2) {
+                addError(localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
+            }
+            else {
+                validateAnnotatedMetadata(errorNode, typeArgs[0].type, typeArgs.slice(1));
+            }
         }
         if (!typeArgs || typeArgs.length === 0) {
             return { type: types_1.AnyType.create() };
@@ -10882,6 +10926,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isNotRequired: typeArgs[0].isNotRequired,
         };
     }
+    // Enforces metadata consistency as specified in PEP 746.
+    function validateAnnotatedMetadata(errorNode, annotatedType, metaArgs) {
+        var _a;
+        // This is an experimental feature because PEP 746 hasn't been accepted.
+        if (!AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
+            return;
+        }
+        for (const metaArg of metaArgs) {
+            if ((0, types_1.isClass)(metaArg.type)) {
+                const supportsTypeMethod = (_a = getTypeOfBoundMember(
+                /* errorNode */ undefined, metaArg.type, '__supports_type__')) === null || _a === void 0 ? void 0 : _a.type;
+                if (!supportsTypeMethod) {
+                    continue;
+                }
+                // "Call" the __supports_type__ method to determine if the type is supported.
+                const callResult = useSpeculativeMode(errorNode, () => validateCallArguments(errorNode, [
+                    {
+                        argumentCategory: 0 /* ArgumentCategory.Simple */,
+                        typeResult: { type: (0, typeUtils_1.convertToInstance)(annotatedType) },
+                    },
+                ], { type: supportsTypeMethod }, 
+                /* typeVarContext */ undefined, 
+                /* skipUnknownArgCheck */ true, 
+                /* inferenceContext */ undefined, 
+                /* signatureTracker */ undefined));
+                if (callResult.isTypeIncomplete || !callResult.returnType) {
+                    continue;
+                }
+                // If there are no errors and the return type is potentially truthy,
+                // we know that the type is supported by this metadata object.
+                if (!callResult.argumentErrors && canBeTruthy(callResult.returnType)) {
+                    continue;
+                }
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.annotatedMetadataInconsistent().format({
+                    metadataType: printType(metaArg.type),
+                    type: printType((0, typeUtils_1.convertToInstance)(annotatedType)),
+                }), metaArg.node);
+            }
+        }
+    }
     // Creates one of several "special" types that are defined in typing.pyi
     // but not declared in their entirety. This includes the likes of "Tuple",
     // "Dict", etc.
@@ -11113,10 +11197,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Determine if there are any generic type parameters associated
             // with this type alias.
             typeParameters = [];
-            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-                (0, debug_1.assert)(typeParameters !== undefined);
-                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(subtype));
-            });
+            (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(type));
             // Don't include any synthesized type variables.
             typeParameters = typeParameters.filter((typeVar) => !typeVar.details.isSynthesized);
         }
@@ -11185,7 +11266,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined);
         if (aliasMapEntry.isSpecialForm) {
-            specialClassType.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
+            specialClassType.details.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
         }
         // Synthesize a single type parameter with the specified variance if
         // specified in the alias map entry.
@@ -11198,7 +11279,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const specialBuiltInClassDeclaration = ((_a = AnalyzerNodeInfo.getDeclaration(node)) !== null && _a !== void 0 ? _a : (node.parent ? AnalyzerNodeInfo.getDeclaration(node.parent) : undefined));
         specialClassType.details.declaration = specialBuiltInClassDeclaration;
         if (fileInfo.isTypingExtensionsStubFile) {
-            specialClassType.details.flags |= 131072 /* ClassTypeFlags.TypingExtensionClass */;
+            specialClassType.details.flags |= 4096 /* ClassTypeFlags.TypingExtensionClass */;
         }
         const baseClassName = aliasMapEntry.alias || 'object';
         let baseClass;
@@ -11218,7 +11299,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // cause the TypedDict to be marked as abstract.
                 if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
                     baseClass = types_1.ClassType.cloneWithNewFlags(baseClass, baseClass.details.flags &
-                        ~(2048 /* ClassTypeFlags.SupportsAbstractMethods */ | 268435456 /* ClassTypeFlags.TypeCheckOnly */));
+                        ~(64 /* ClassTypeFlags.SupportsAbstractMethods */ | 1048576 /* ClassTypeFlags.TypeCheckOnly */));
                 }
             }
         }
@@ -11461,7 +11542,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        assignTypeToExpression(node.leftExpression, rightHandType, isIncomplete, node.rightExpression, 
+        assignTypeToExpression(node.leftExpression, { type: rightHandType, isIncomplete }, node.rightExpression, 
         /* ignoreEmptyContainers */ true, 
         /* allowAssignmentToFinalVar */ true, expectedTypeDiagAddendum);
         writeTypeCache(node, { type: rightHandType, isIncomplete }, 0 /* EvaluatorFlags.None */);
@@ -11593,17 +11674,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             fileInfo.isTypeshedStubFile) {
             classFlags |= 1 /* ClassTypeFlags.BuiltInClass */;
             if (fileInfo.isTypingExtensionsStubFile) {
-                classFlags |= 131072 /* ClassTypeFlags.TypingExtensionClass */;
+                classFlags |= 4096 /* ClassTypeFlags.TypingExtensionClass */;
             }
             if (node.name.value === 'property') {
-                classFlags |= 4096 /* ClassTypeFlags.PropertyClass */;
+                classFlags |= 128 /* ClassTypeFlags.PropertyClass */;
             }
             if (node.name.value === 'tuple') {
-                classFlags |= 1048576 /* ClassTypeFlags.TupleClass */;
+                classFlags |= 32768 /* ClassTypeFlags.TupleClass */;
             }
         }
         if (fileInfo.isStubFile) {
-            classFlags |= 16777216 /* ClassTypeFlags.DefinedInStub */;
+            classFlags |= 262144 /* ClassTypeFlags.DefinedInStub */;
         }
         const classType = types_1.ClassType.createInstantiable(node.name.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, 
         /* typeSourceId */ 0, 
@@ -11626,9 +11707,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (classDecl && classSymbol) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
-        classType.details.flags |= 262144 /* ClassTypeFlags.PartiallyEvaluated */;
+        classType.details.flags |= 8192 /* ClassTypeFlags.PartiallyEvaluated */;
         classType.details.declaration = classDecl;
-        try {
+        return (0, cancellationUtils_1.invalidateTypeCacheIfCanceled)(() => {
             writeTypeCache(node, { type: classType }, /* flags */ undefined);
             writeTypeCache(node.name, { type: classType }, /* flags */ undefined);
             // Keep a list of unique type parameters that are used in the
@@ -11712,29 +11793,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_7)) {
                                     addError(localize_1.LocMessage.protocolIllegal(), arg.valueExpression);
                                 }
-                                classType.details.flags |= 16384 /* ClassTypeFlags.ProtocolClass */;
+                                classType.details.flags |= 512 /* ClassTypeFlags.ProtocolClass */;
                             }
                             if (types_1.ClassType.isBuiltIn(argType, 'property')) {
-                                classType.details.flags |= 4096 /* ClassTypeFlags.PropertyClass */;
+                                classType.details.flags |= 128 /* ClassTypeFlags.PropertyClass */;
                             }
                             // If the class directly derives from NamedTuple (in Python 3.6 or
                             // newer), it's considered a (read-only) dataclass.
                             if (fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_6)) {
                                 if (types_1.ClassType.isBuiltIn(argType, 'NamedTuple')) {
                                     isNamedTupleSubclass = true;
-                                    classType.details.flags |=
-                                        4 /* ClassTypeFlags.DataClass */ |
-                                            32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */ |
-                                            33554432 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
+                                    classType.details.flags |= 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
                                 }
                             }
                             // If the class directly derives from TypedDict or from a class that is
                             // a TypedDict, it is considered a TypedDict.
                             if (types_1.ClassType.isBuiltIn(argType, 'TypedDict') || types_1.ClassType.isTypedDictClass(argType)) {
-                                classType.details.flags |= 128 /* ClassTypeFlags.TypedDictClass */;
+                                classType.details.flags |= 4 /* ClassTypeFlags.TypedDictClass */;
                                 // Propagate the "effectively closed" flag from base classes.
                                 if (types_1.ClassType.isTypedDictEffectivelyClosed(argType)) {
-                                    classType.details.flags |= 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                    classType.details.flags |= 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
                                 }
                             }
                             // Validate that the class isn't deriving from itself, creating a
@@ -11765,7 +11843,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     classType.details.baseClasses.push(argType);
                     if ((0, types_1.isInstantiableClass)(argType)) {
                         if (types_1.ClassType.isEnumClass(argType)) {
-                            classType.details.flags |= 2097152 /* ClassTypeFlags.EnumClass */;
+                            classType.details.flags |= 65536 /* ClassTypeFlags.EnumClass */;
                         }
                         // Determine if the class is abstract. Protocol classes support abstract methods
                         // because they are constructed by the _ProtocolMeta metaclass, which derives
@@ -11774,10 +11852,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // because of dependencies on some of these built-in protocol classes.
                         if (types_1.ClassType.supportsAbstractMethods(argType) ||
                             (types_1.ClassType.isProtocolClass(argType) && !types_1.ClassType.isBuiltIn(argType))) {
-                            classType.details.flags |= 2048 /* ClassTypeFlags.SupportsAbstractMethods */;
+                            classType.details.flags |= 64 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                         if (types_1.ClassType.isPropertyClass(argType)) {
-                            classType.details.flags |= 4096 /* ClassTypeFlags.PropertyClass */;
+                            classType.details.flags |= 128 /* ClassTypeFlags.PropertyClass */;
                         }
                         if (types_1.ClassType.isFinal(argType)) {
                             const className = printObjectTypeForClass(argType);
@@ -11827,13 +11905,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             addError(localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
                         }
                         else if (arg.name.value === 'total' && !constArgValue) {
-                            classType.details.flags |= 1024 /* ClassTypeFlags.CanOmitDictValues */;
+                            classType.details.flags |= 32 /* ClassTypeFlags.CanOmitDictValues */;
                         }
                         else if (arg.name.value === 'closed' && constArgValue) {
                             // This is an experimental feature because PEP 728 hasn't been accepted yet.
                             if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
                                 classType.details.flags |=
-                                    256 /* ClassTypeFlags.TypedDictMarkedClosed */ | 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                    8 /* ClassTypeFlags.TypedDictMarkedClosed */ | 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
                             }
                         }
                     }
@@ -11966,7 +12044,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 param.category === 0 /* ParameterCategory.Simple */ &&
                                 !param.defaultValue);
                             if (genericParams.length > 0) {
-                                classType.details.flags |= 32768 /* ClassTypeFlags.PseudoGenericClass */;
+                                classType.details.flags |= 1024 /* ClassTypeFlags.PseudoGenericClass */;
                                 // Create a type parameter for each simple, named parameter
                                 // in the __init__ method.
                                 classType.details.typeParameters = genericParams.map((param) => {
@@ -11987,7 +12065,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (classType.details.typeParameters.length === 0 && !types_1.ClassType.isBuiltIn(classType, 'type')) {
                 if (classType.details.baseClasses.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.hasCustomClassGetItem(baseClass)) ||
                     classType.details.fields.has('__class_getitem__')) {
-                    classType.details.flags |= 524288 /* ClassTypeFlags.HasCustomClassGetItem */;
+                    classType.details.flags |= 16384 /* ClassTypeFlags.HasCustomClassGetItem */;
                 }
             }
             // Determine the effective metaclass.
@@ -12000,17 +12078,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     classType.details.declaredMetaclass = metaclassType;
                     if ((0, types_1.isInstantiableClass)(metaclassType)) {
                         if ((0, enums_1.isEnumMetaclass)(metaclassType)) {
-                            classType.details.flags |= 2097152 /* ClassTypeFlags.EnumClass */;
+                            classType.details.flags |= 65536 /* ClassTypeFlags.EnumClass */;
                         }
                         if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
-                            classType.details.flags |= 2048 /* ClassTypeFlags.SupportsAbstractMethods */;
+                            classType.details.flags |= 64 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                     }
                 }
             }
             const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
             // Clear the "partially constructed" flag.
-            classType.details.flags &= ~262144 /* ClassTypeFlags.PartiallyEvaluated */;
+            classType.details.flags &= ~8192 /* ClassTypeFlags.PartiallyEvaluated */;
             // Now determine the decorated type of the class.
             let decoratedType = classType;
             let foundUnknown = false;
@@ -12047,7 +12125,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (dataClassBehaviors) {
-                (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
                 (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.name, classType, initSubclassArgs, dataClassBehaviors);
             }
             // Run any deferred class completions that depend on this class.
@@ -12075,8 +12152,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType);
             }
             // Synthesize dataclass methods.
-            if (types_1.ClassType.isDataClass(classType)) {
-                const skipSynthesizedInit = types_1.ClassType.isSkipSynthesizedDataClassInit(classType);
+            if (types_1.ClassType.isDataClass(classType) || isNamedTupleSubclass) {
+                const skipSynthesizedInit = types_1.ClassType.isDataClassSkipGenerateInit(classType);
                 let hasExistingInitMethod = skipSynthesizedInit;
                 // See if there's already a non-synthesized __init__ method.
                 // We shouldn't override it.
@@ -12142,15 +12219,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Update the decorated class type.
             writeTypeCache(node, { type: decoratedType }, 0 /* EvaluatorFlags.None */);
             return { classType, decoratedType };
-        }
-        catch (e) {
-            if (cancellationUtils_1.OperationCanceledException.is(e)) {
-                // If the work was canceled before the class types were updated, the
-                // class type in the type cache is in an invalid, partially-constructed state.
-                e.isTypeCacheInvalid = true;
-            }
-            throw e;
-        }
+        });
     }
     // Determines whether the type parameters has a default that refers to another
     // type parameter. If so, validates that it is in the list of "live" type
@@ -12566,7 +12635,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Evaluates the type of a "def" statement without applying an async
     // modifier or any decorators.
     function getTypeOfFunctionPredecorated(node) {
-        var _a, _b, _c;
+        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // Is this type already cached?
         const cachedFunctionType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
@@ -12621,299 +12690,303 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (functionDecl && functionSymbol) {
             setSymbolResolutionPartialType(functionSymbol.symbol, functionDecl, functionType);
         }
-        writeTypeCache(node.name, { type: functionType }, /* flags */ undefined);
-        // Is this an "__init__" method within a pseudo-generic class? If so,
-        // we'll add generic types to the constructor's parameters.
-        const addGenericParamTypes = containingClassType &&
-            types_1.ClassType.isPseudoGenericClass(containingClassType) &&
-            node.name.value === '__init__';
-        const paramTypes = [];
-        // Determine if the first parameter should be skipped for comment-based
-        // function annotations.
-        let firstCommentAnnotationIndex = 0;
-        if (containingClassType && (functionType.details.flags & 4 /* FunctionTypeFlags.StaticMethod */) === 0) {
-            firstCommentAnnotationIndex = 1;
-        }
-        // If there is a function annotation comment, validate that it has the correct
-        // number of parameter annotations.
-        if (node.functionAnnotationComment && !node.functionAnnotationComment.isParamListEllipsis) {
-            const expected = node.parameters.length - firstCommentAnnotationIndex;
-            const received = node.functionAnnotationComment.paramTypeAnnotations.length;
-            // For methods with "self" or "cls" parameters, the annotation list
-            // can either include or exclude the annotation for the first parameter.
-            if (firstCommentAnnotationIndex > 0 && received === node.parameters.length) {
-                firstCommentAnnotationIndex = 0;
-            }
-            else if (received !== expected) {
-                addError(localize_1.LocMessage.annotatedParamCountMismatch().format({
-                    expected,
-                    received,
-                }), node.functionAnnotationComment);
-            }
-        }
-        // If this function uses PEP 695 syntax for type parameters,
-        // accumulate the list of type parameters upfront.
-        const typeParametersSeen = [];
-        if (node.typeParameters) {
-            functionType.details.typeParameters = evaluateTypeParameterList(node.typeParameters).map((typeParam) => (0, typeUtils_1.convertToInstance)(typeParam));
-        }
-        else {
-            functionType.details.typeParameters = typeParametersSeen;
-        }
-        let paramsArePositionOnly = true;
-        const isFirstParamClsOrSelf = containingClassType &&
-            (types_1.FunctionType.isClassMethod(functionType) ||
-                types_1.FunctionType.isInstanceMethod(functionType) ||
-                types_1.FunctionType.isConstructorMethod(functionType));
-        const firstNonClsSelfParamIndex = isFirstParamClsOrSelf ? 1 : 0;
-        node.parameters.forEach((param, index) => {
-            let paramType;
-            let annotatedType;
-            let paramTypeNode;
-            if (param.name) {
-                if (index === 0 && isFirstParamClsOrSelf) {
-                    // Mark "self/cls" as accessed.
-                    markParamAccessed(param);
-                }
-                else if (types_1.FunctionType.isAbstractMethod(functionType)) {
-                    // Mark all parameters in abstract methods as accessed.
-                    markParamAccessed(param);
-                }
-                else if (containingClassType && types_1.ClassType.isProtocolClass(containingClassType)) {
-                    // Mark all parameters in protocol methods as accessed.
-                    markParamAccessed(param);
-                }
-            }
-            if (param.typeAnnotation) {
-                paramTypeNode = param.typeAnnotation;
-            }
-            else if (param.typeAnnotationComment) {
-                paramTypeNode = param.typeAnnotationComment;
+        return (0, cancellationUtils_1.invalidateTypeCacheIfCanceled)(() => {
+            var _a, _b;
+            writeTypeCache(node.name, { type: functionType }, /* flags */ undefined);
+            // Is this an "__init__" method within a pseudo-generic class? If so,
+            // we'll add generic types to the constructor's parameters.
+            const addGenericParamTypes = containingClassType &&
+                types_1.ClassType.isPseudoGenericClass(containingClassType) &&
+                node.name.value === '__init__';
+            const paramTypes = [];
+            // Determine if the first parameter should be skipped for comment-based
+            // function annotations.
+            let firstCommentAnnotationIndex = 0;
+            if (containingClassType && (functionType.details.flags & 4 /* FunctionTypeFlags.StaticMethod */) === 0) {
+                firstCommentAnnotationIndex = 1;
+            }
+            // If there is a function annotation comment, validate that it has the correct
+            // number of parameter annotations.
+            if (node.functionAnnotationComment && !node.functionAnnotationComment.isParamListEllipsis) {
+                const expected = node.parameters.length - firstCommentAnnotationIndex;
+                const received = node.functionAnnotationComment.paramTypeAnnotations.length;
+                // For methods with "self" or "cls" parameters, the annotation list
+                // can either include or exclude the annotation for the first parameter.
+                if (firstCommentAnnotationIndex > 0 && received === node.parameters.length) {
+                    firstCommentAnnotationIndex = 0;
+                }
+                else if (received !== expected) {
+                    addError(localize_1.LocMessage.annotatedParamCountMismatch().format({
+                        expected,
+                        received,
+                    }), node.functionAnnotationComment);
+                }
+            }
+            // If this function uses PEP 695 syntax for type parameters,
+            // accumulate the list of type parameters upfront.
+            const typeParametersSeen = [];
+            if (node.typeParameters) {
+                functionType.details.typeParameters = evaluateTypeParameterList(node.typeParameters).map((typeParam) => (0, typeUtils_1.convertToInstance)(typeParam));
             }
-            else if (node.functionAnnotationComment && !node.functionAnnotationComment.isParamListEllipsis) {
-                const adjustedIndex = index - firstCommentAnnotationIndex;
-                if (adjustedIndex >= 0 && adjustedIndex < node.functionAnnotationComment.paramTypeAnnotations.length) {
-                    paramTypeNode = node.functionAnnotationComment.paramTypeAnnotations[adjustedIndex];
-                }
+            else {
+                functionType.details.typeParameters = typeParametersSeen;
             }
-            if (paramTypeNode) {
-                if ((functionInfo.flags & 524288 /* FunctionTypeFlags.NoTypeCheck */) !== 0) {
-                    annotatedType = types_1.UnknownType.create();
+            let paramsArePositionOnly = true;
+            const isFirstParamClsOrSelf = containingClassType &&
+                (types_1.FunctionType.isClassMethod(functionType) ||
+                    types_1.FunctionType.isInstanceMethod(functionType) ||
+                    types_1.FunctionType.isConstructorMethod(functionType));
+            const firstNonClsSelfParamIndex = isFirstParamClsOrSelf ? 1 : 0;
+            node.parameters.forEach((param, index) => {
+                let paramType;
+                let annotatedType;
+                let paramTypeNode;
+                if (param.name) {
+                    if (index === 0 && isFirstParamClsOrSelf) {
+                        // Mark "self/cls" as accessed.
+                        markParamAccessed(param);
+                    }
+                    else if (types_1.FunctionType.isAbstractMethod(functionType)) {
+                        // Mark all parameters in abstract methods as accessed.
+                        markParamAccessed(param);
+                    }
+                    else if (containingClassType && types_1.ClassType.isProtocolClass(containingClassType)) {
+                        // Mark all parameters in protocol methods as accessed.
+                        markParamAccessed(param);
+                    }
                 }
-                else {
-                    annotatedType = getTypeOfParameterAnnotation(paramTypeNode, param.category);
+                if (param.typeAnnotation) {
+                    paramTypeNode = param.typeAnnotation;
                 }
-                if (annotatedType) {
-                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(annotatedType), functionType.details.typeVarScopeId);
+                else if (param.typeAnnotationComment) {
+                    paramTypeNode = param.typeAnnotationComment;
                 }
-                if ((0, types_1.isVariadicTypeVar)(annotatedType) && !annotatedType.isVariadicUnpacked) {
-                    addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
-                        name1: annotatedType.details.name,
-                        name2: annotatedType.details.name,
-                    }), paramTypeNode);
-                    annotatedType = types_1.UnknownType.create();
+                else if (node.functionAnnotationComment && !node.functionAnnotationComment.isParamListEllipsis) {
+                    const adjustedIndex = index - firstCommentAnnotationIndex;
+                    if (adjustedIndex >= 0 &&
+                        adjustedIndex < node.functionAnnotationComment.paramTypeAnnotations.length) {
+                        paramTypeNode = node.functionAnnotationComment.paramTypeAnnotations[adjustedIndex];
+                    }
                 }
-            }
-            if (!annotatedType && addGenericParamTypes) {
-                if (index > 0 && param.category === 0 /* ParameterCategory.Simple */ && param.name && !param.defaultValue) {
-                    const typeParamName = getPseudoGenericTypeVarName(param.name.value);
-                    annotatedType = containingClassType.details.typeParameters.find((param) => param.details.name === typeParamName);
+                if (paramTypeNode) {
+                    if ((functionInfo.flags & 524288 /* FunctionTypeFlags.NoTypeCheck */) !== 0) {
+                        annotatedType = types_1.UnknownType.create();
+                    }
+                    else {
+                        annotatedType = getTypeOfParameterAnnotation(paramTypeNode, param.category);
+                    }
+                    if (annotatedType) {
+                        (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(annotatedType), functionType.details.typeVarScopeId);
+                    }
+                    if ((0, types_1.isVariadicTypeVar)(annotatedType) && !annotatedType.isVariadicUnpacked) {
+                        addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
+                            name1: annotatedType.details.name,
+                            name2: annotatedType.details.name,
+                        }), paramTypeNode);
+                        annotatedType = types_1.UnknownType.create();
+                    }
                 }
-            }
-            if (annotatedType) {
-                const adjustedAnnotatedType = adjustParameterAnnotatedType(param, annotatedType);
-                if (adjustedAnnotatedType !== annotatedType) {
-                    annotatedType = adjustedAnnotatedType;
+                if (!annotatedType && addGenericParamTypes) {
+                    if (index > 0 && param.category === 0 /* ParameterCategory.Simple */ && param.name && !param.defaultValue) {
+                        const typeParamName = getPseudoGenericTypeVarName(param.name.value);
+                        annotatedType = containingClassType.details.typeParameters.find((param) => param.details.name === typeParamName);
+                    }
                 }
-            }
-            let defaultValueType;
-            if (param.defaultValue) {
-                // 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 (annotatedType) {
+                    const adjustedAnnotatedType = adjustParameterAnnotatedType(param, annotatedType);
+                    if (adjustedAnnotatedType !== annotatedType) {
+                        annotatedType = adjustedAnnotatedType;
+                    }
                 }
-                if (types_1.FunctionType.isOverloaded(functionType) || types_1.FunctionType.isAbstractMethod(functionType)) {
-                    treatEllipsisAsAny = true;
+                let defaultValueType;
+                if (param.defaultValue) {
+                    // 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 /* EvaluatorFlags.ConvertEllipsisToAny */ : 0 /* EvaluatorFlags.None */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
                 }
-                defaultValueType = getTypeOfExpression(param.defaultValue, treatEllipsisAsAny ? 1 /* EvaluatorFlags.ConvertEllipsisToAny */ : 0 /* EvaluatorFlags.None */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
-            }
-            if (annotatedType) {
-                // If there was both a type annotation and a default value, verify
-                // that the default value matches the annotation.
-                if (param.defaultValue && defaultValueType) {
-                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                    const typeVarContext = new typeVarContext_1.TypeVarContext(functionType.details.typeVarScopeId);
-                    if (containingClassType && containingClassType.details.typeVarScopeId !== undefined) {
-                        if (node.name.value === '__init__' || node.name.value === '__new__') {
-                            typeVarContext.addSolveForScope(containingClassType.details.typeVarScopeId);
+                if (annotatedType) {
+                    // If there was both a type annotation and a default value, verify
+                    // that the default value matches the annotation.
+                    if (param.defaultValue && defaultValueType) {
+                        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                        const typeVarContext = new typeVarContext_1.TypeVarContext(functionType.details.typeVarScopeId);
+                        if (containingClassType && containingClassType.details.typeVarScopeId !== undefined) {
+                            if (node.name.value === '__init__' || node.name.value === '__new__') {
+                                typeVarContext.addSolveForScope(containingClassType.details.typeVarScopeId);
+                            }
+                        }
+                        if (!assignType(annotatedType, defaultValueType, diagAddendum, typeVarContext)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.paramAssignmentMismatch().format({
+                                sourceType: printType(defaultValueType),
+                                paramType: printType(annotatedType),
+                            }) + diagAddendum.getString(), param.defaultValue);
                         }
                     }
-                    if (!assignType(annotatedType, defaultValueType, diagAddendum, typeVarContext)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.paramAssignmentMismatch().format({
-                            sourceType: printType(defaultValueType),
-                            paramType: printType(annotatedType),
-                        }) + diagAddendum.getString(), param.defaultValue);
-                    }
-                }
-                paramType = annotatedType;
-            }
-            // Determine whether we need to insert an implied position-only parameter.
-            // This is needed when a function's parameters are named using the old-style
-            // way of specifying position-only parameters.
-            if (index >= firstNonClsSelfParamIndex) {
-                let isImplicitPositionOnlyParam = false;
-                if (param.category === 0 /* ParameterCategory.Simple */ && param.name) {
-                    if ((0, symbolNameUtils_1.isPrivateName)(param.name.value) &&
-                        !node.parameters.some((p) => p.category === 0 /* ParameterCategory.Simple */ && !p.name)) {
-                        isImplicitPositionOnlyParam = true;
-                        // If the parameter name indicates an implicit position-only parameter
-                        // but we have already seen non-position-only parameters, report an error.
-                        if (!paramsArePositionOnly &&
-                            functionType.details.parameters.every((p) => p.category === 0 /* ParameterCategory.Simple */)) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.positionOnlyAfterNon(), param.name);
+                    paramType = annotatedType;
+                }
+                // Determine whether we need to insert an implied position-only parameter.
+                // This is needed when a function's parameters are named using the old-style
+                // way of specifying position-only parameters.
+                if (index >= firstNonClsSelfParamIndex) {
+                    let isImplicitPositionOnlyParam = false;
+                    if (param.category === 0 /* ParameterCategory.Simple */ && param.name) {
+                        if ((0, symbolNameUtils_1.isPrivateName)(param.name.value) &&
+                            !node.parameters.some((p) => p.category === 0 /* ParameterCategory.Simple */ && !p.name)) {
+                            isImplicitPositionOnlyParam = true;
+                            // If the parameter name indicates an implicit position-only parameter
+                            // but we have already seen non-position-only parameters, report an error.
+                            if (!paramsArePositionOnly &&
+                                functionType.details.parameters.every((p) => p.category === 0 /* ParameterCategory.Simple */)) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.positionOnlyAfterNon(), param.name);
+                            }
                         }
                     }
+                    else {
+                        paramsArePositionOnly = false;
+                    }
+                    if (paramsArePositionOnly &&
+                        !isImplicitPositionOnlyParam &&
+                        functionType.details.parameters.length > firstNonClsSelfParamIndex) {
+                        types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                    }
+                    if (!isImplicitPositionOnlyParam) {
+                        paramsArePositionOnly = false;
+                    }
+                }
+                // If there was no annotation for the parameter, infer its type if possible.
+                let isTypeInferred = false;
+                if (!paramTypeNode) {
+                    isTypeInferred = true;
+                    const inferredType = inferParameterType(node, functionType.details.flags, index, containingClassType);
+                    if (inferredType) {
+                        paramType = inferredType;
+                    }
+                }
+                const functionParam = {
+                    category: param.category,
+                    name: param.name ? param.name.value : undefined,
+                    hasDefault: !!param.defaultValue,
+                    defaultValueExpression: param.defaultValue,
+                    defaultType: defaultValueType,
+                    type: paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(),
+                    typeAnnotation: paramTypeNode,
+                    hasDeclaredType: !!paramTypeNode,
+                    isTypeInferred,
+                };
+                types_1.FunctionType.addParameter(functionType, functionParam);
+                if (functionParam.hasDeclaredType) {
+                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionParam.type), functionType.details.typeVarScopeId);
                 }
-                else {
-                    paramsArePositionOnly = false;
+                if (param.name) {
+                    const variadicParamType = transformVariadicParamType(node, param.category, functionParam.type);
+                    paramTypes.push(variadicParamType);
                 }
-                if (paramsArePositionOnly &&
-                    !isImplicitPositionOnlyParam &&
-                    functionType.details.parameters.length > firstNonClsSelfParamIndex) {
-                    types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                else {
+                    paramTypes.push(functionParam.type);
                 }
-                if (!isImplicitPositionOnlyParam) {
-                    paramsArePositionOnly = false;
-                }
-            }
-            // If there was no annotation for the parameter, infer its type if possible.
-            let isTypeInferred = false;
-            if (!paramTypeNode) {
-                isTypeInferred = true;
-                const inferredType = inferParameterType(node, functionType.details.flags, index, containingClassType);
-                if (inferredType) {
-                    paramType = inferredType;
-                }
-            }
-            const functionParam = {
-                category: param.category,
-                name: param.name ? param.name.value : undefined,
-                hasDefault: !!param.defaultValue,
-                defaultValueExpression: param.defaultValue,
-                defaultType: defaultValueType,
-                type: paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(),
-                typeAnnotation: paramTypeNode,
-                hasDeclaredType: !!paramTypeNode,
-                isTypeInferred,
-            };
-            types_1.FunctionType.addParameter(functionType, functionParam);
-            if (functionParam.hasDeclaredType) {
-                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionParam.type), functionType.details.typeVarScopeId);
-            }
-            if (param.name) {
-                const variadicParamType = transformVariadicParamType(node, param.category, functionParam.type);
-                paramTypes.push(variadicParamType);
-            }
-            else {
-                paramTypes.push(functionParam.type);
+            });
+            if (paramsArePositionOnly && functionType.details.parameters.length > firstNonClsSelfParamIndex) {
+                types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
             }
-        });
-        if (paramsArePositionOnly && functionType.details.parameters.length > firstNonClsSelfParamIndex) {
-            types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
-        }
-        // Update the types for the nodes associated with the parameters.
-        paramTypes.forEach((paramType, index) => {
-            const paramNameNode = node.parameters[index].name;
-            if (paramNameNode) {
-                if ((0, types_1.isUnknown)(paramType)) {
-                    functionType.details.flags |= 16384 /* FunctionTypeFlags.UnannotatedParams */;
+            // Update the types for the nodes associated with the parameters.
+            paramTypes.forEach((paramType, index) => {
+                const paramNameNode = node.parameters[index].name;
+                if (paramNameNode) {
+                    if ((0, types_1.isUnknown)(paramType)) {
+                        functionType.details.flags |= 16384 /* FunctionTypeFlags.UnannotatedParams */;
+                    }
+                    writeTypeCache(paramNameNode, { type: paramType }, 0 /* EvaluatorFlags.None */);
                 }
-                writeTypeCache(paramNameNode, { type: paramType }, 0 /* EvaluatorFlags.None */);
-            }
-        });
-        // If the function ends in P.args and P.kwargs parameters, make it exempt from
-        // args/kwargs compatibility checks. This is important for protocol comparisons.
-        if (paramTypes.length >= 2) {
-            const paramType1 = paramTypes[paramTypes.length - 2];
-            const paramType2 = paramTypes[paramTypes.length - 1];
-            if ((0, types_1.isParamSpec)(paramType1) &&
-                paramType1.paramSpecAccess === 'args' &&
-                (0, types_1.isParamSpec)(paramType2) &&
-                paramType2.paramSpecAccess === 'kwargs') {
-                functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
-            }
-        }
-        // If the function contains an *args and a **kwargs parameter and both
-        // are annotated as Any or are unannotated, make it exempt from
-        // args/kwargs compatibility checks.
-        const variadicsWithAnyType = functionType.details.parameters.filter((param) => param.category !== 0 /* ParameterCategory.Simple */ && param.name && (0, types_1.isAnyOrUnknown)(param.type));
-        if (variadicsWithAnyType.length >= 2) {
-            functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
-        }
-        // If there was a defined return type, analyze that first so when we
-        // walk the contents of the function, return statements can be
-        // validated against this type.
-        const returnTypeAnnotationNode = (_b = node.returnTypeAnnotation) !== null && _b !== void 0 ? _b : (_c = node.functionAnnotationComment) === null || _c === void 0 ? void 0 : _c.returnTypeAnnotation;
-        if (returnTypeAnnotationNode) {
-            // Temporarily set the return type to unknown in case of recursion.
-            functionType.details.declaredReturnType = types_1.UnknownType.create();
-            const returnType = getTypeOfAnnotation(returnTypeAnnotationNode, {
-                associateTypeVarsWithScope: true,
             });
-            functionType.details.declaredReturnType = returnType;
-        }
-        else {
-            // If there was no return type annotation and this is a type stub,
-            // we have no opportunity to infer the return type, so we'll indicate
-            // that it's unknown.
-            if (fileInfo.isStubFile) {
-                // Special-case the __init__ method, which is commonly left without
-                // an annotated return type, but we can assume it returns None.
-                if (node.name.value === '__init__') {
-                    functionType.details.declaredReturnType = getNoneType();
-                }
-                else {
-                    functionType.details.declaredReturnType = types_1.UnknownType.create();
+            // If the function ends in P.args and P.kwargs parameters, make it exempt from
+            // args/kwargs compatibility checks. This is important for protocol comparisons.
+            if (paramTypes.length >= 2) {
+                const paramType1 = paramTypes[paramTypes.length - 2];
+                const paramType2 = paramTypes[paramTypes.length - 1];
+                if ((0, types_1.isParamSpec)(paramType1) &&
+                    paramType1.paramSpecAccess === 'args' &&
+                    (0, types_1.isParamSpec)(paramType2) &&
+                    paramType2.paramSpecAccess === 'kwargs') {
+                    functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+                }
+            }
+            // If the function contains an *args and a **kwargs parameter and both
+            // are annotated as Any or are unannotated, make it exempt from
+            // args/kwargs compatibility checks.
+            const variadicsWithAnyType = functionType.details.parameters.filter((param) => param.category !== 0 /* ParameterCategory.Simple */ && param.name && (0, types_1.isAnyOrUnknown)(param.type));
+            if (variadicsWithAnyType.length >= 2) {
+                functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+            }
+            // If there was a defined return type, analyze that first so when we
+            // walk the contents of the function, return statements can be
+            // validated against this type.
+            const returnTypeAnnotationNode = (_a = node.returnTypeAnnotation) !== null && _a !== void 0 ? _a : (_b = node.functionAnnotationComment) === null || _b === void 0 ? void 0 : _b.returnTypeAnnotation;
+            if (returnTypeAnnotationNode) {
+                // Temporarily set the return type to unknown in case of recursion.
+                functionType.details.declaredReturnType = types_1.UnknownType.create();
+                const returnType = getTypeOfAnnotation(returnTypeAnnotationNode, {
+                    associateTypeVarsWithScope: true,
+                });
+                functionType.details.declaredReturnType = returnType;
+            }
+            else {
+                // If there was no return type annotation and this is a type stub,
+                // we have no opportunity to infer the return type, so we'll indicate
+                // that it's unknown.
+                if (fileInfo.isStubFile) {
+                    // Special-case the __init__ method, which is commonly left without
+                    // an annotated return type, but we can assume it returns None.
+                    if (node.name.value === '__init__') {
+                        functionType.details.declaredReturnType = getNoneType();
+                    }
+                    else {
+                        functionType.details.declaredReturnType = types_1.UnknownType.create();
+                    }
                 }
             }
-        }
-        // Accumulate any type parameters used in the return type.
-        if (functionType.details.declaredReturnType && returnTypeAnnotationNode) {
-            (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionType.details.declaredReturnType), functionType.details.typeVarScopeId);
-        }
-        // If the return type is explicitly annotated as a generator, mark the
-        // function as a generator even though it may not contain a "yield" statement.
-        // This is important for generator functions declared in stub files, abstract
-        // methods or protocol definitions.
-        if (fileInfo.isStubFile || ParseTreeUtils.isSuiteEmpty(node.suite)) {
-            if (functionType.details.declaredReturnType &&
-                (0, types_1.isClassInstance)(functionType.details.declaredReturnType) &&
-                types_1.ClassType.isBuiltIn(functionType.details.declaredReturnType, [
-                    'Generator',
-                    'AsyncGenerator',
-                    'AwaitableGenerator',
-                ])) {
-                functionType.details.flags |= 16 /* FunctionTypeFlags.Generator */;
+            // Accumulate any type parameters used in the return type.
+            if (functionType.details.declaredReturnType && returnTypeAnnotationNode) {
+                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionType.details.declaredReturnType), functionType.details.typeVarScopeId);
             }
-        }
-        // Validate the default types for all type parameters.
-        functionType.details.typeParameters.forEach((typeParam, index) => {
-            var _a;
-            let bestErrorNode = node.name;
-            if (node.typeParameters && index < node.typeParameters.parameters.length) {
-                const typeParamNode = node.typeParameters.parameters[index];
-                bestErrorNode = (_a = typeParamNode.defaultExpression) !== null && _a !== void 0 ? _a : typeParamNode.name;
+            // If the return type is explicitly annotated as a generator, mark the
+            // function as a generator even though it may not contain a "yield" statement.
+            // This is important for generator functions declared in stub files, abstract
+            // methods or protocol definitions.
+            if (fileInfo.isStubFile || ParseTreeUtils.isSuiteEmpty(node.suite)) {
+                if (functionType.details.declaredReturnType &&
+                    (0, types_1.isClassInstance)(functionType.details.declaredReturnType) &&
+                    types_1.ClassType.isBuiltIn(functionType.details.declaredReturnType, [
+                        'Generator',
+                        'AsyncGenerator',
+                        'AwaitableGenerator',
+                    ])) {
+                    functionType.details.flags |= 16 /* FunctionTypeFlags.Generator */;
+                }
             }
-            validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index), functionType.details.typeVarScopeId);
+            // Validate the default types for all type parameters.
+            functionType.details.typeParameters.forEach((typeParam, index) => {
+                var _a;
+                let bestErrorNode = node.name;
+                if (node.typeParameters && index < node.typeParameters.parameters.length) {
+                    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), functionType.details.typeVarScopeId);
+            });
+            // Clear the "partially evaluated" flag to indicate that the functionType
+            // is fully evaluated.
+            functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
+            writeTypeCache(node.name, { type: functionType }, 0 /* EvaluatorFlags.None */);
+            return functionType;
         });
-        // Clear the "partially evaluated" flag to indicate that the functionType
-        // is fully evaluated.
-        functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
-        writeTypeCache(node.name, { type: functionType }, 0 /* EvaluatorFlags.None */);
-        return functionType;
     }
     function markParamAccessed(param) {
         if (param.name) {
@@ -13226,8 +13299,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                         const iteratorTypeResult = getTypeOfExpression(yieldNode.expression);
                                         if ((0, types_1.isClassInstance)(iteratorTypeResult.type) &&
                                             types_1.ClassType.isBuiltIn(iteratorTypeResult.type, 'Coroutine')) {
+                                            const yieldType = iteratorTypeResult.type.typeArguments &&
+                                                iteratorTypeResult.type.typeArguments.length > 0
+                                                ? iteratorTypeResult.type.typeArguments[0]
+                                                : types_1.UnknownType.create();
                                             // Handle old-style (pre-await) Coroutines.
-                                            inferredYieldTypes.push();
+                                            inferredYieldTypes.push(yieldType);
                                             useAwaitableGenerator = true;
                                         }
                                         else {
@@ -13253,9 +13330,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 }
                             });
                         }
-                        if (inferredYieldTypes.length === 0) {
-                            inferredYieldTypes.push(getNoneType());
-                        }
                         const inferredYieldType = (0, types_1.combineTypes)(inferredYieldTypes);
                         // Inferred yield types need to be wrapped in a Generator or
                         // AwaitableGenerator to produce the final result.
@@ -13322,7 +13396,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const iteratorTypeResult = getTypeOfExpression(node.iterableExpression);
         const iteratedType = (_b = (_a = getTypeOfIterator(iteratorTypeResult, !!node.isAsync, node.iterableExpression)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
-        assignTypeToExpression(node.targetExpression, iteratedType, !!iteratorTypeResult.isIncomplete, node.targetExpression);
+        assignTypeToExpression(node.targetExpression, { type: iteratedType, isIncomplete: iteratorTypeResult.isIncomplete }, node.targetExpression);
         writeTypeCache(node, { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
     }
     function evaluateTypesForExceptStatement(node) {
@@ -13371,7 +13445,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             targetType = getBuiltInObject(node, 'BaseExceptionGroup', [targetType]);
         }
         if (node.name) {
-            assignTypeToExpression(node.name, targetType, /* isIncomplete */ false, node.name);
+            assignTypeToExpression(node.name, { type: targetType }, node.name);
         }
         writeTypeCache(node, { type: targetType }, 0 /* EvaluatorFlags.None */);
     }
@@ -13433,7 +13507,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotUsableWith().format({ type: printType(subtype), method: exitMethodName }), node.expression);
         });
         if (node.target) {
-            assignTypeToExpression(node.target, scopedType, !!exprTypeResult.isIncomplete, node.target);
+            assignTypeToExpression(node.target, { type: scopedType, isIncomplete: exprTypeResult.isIncomplete }, node.target);
         }
         writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
     }
@@ -13466,7 +13540,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 symbolType = cachedModuleType;
             }
         }
-        assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
+        assignTypeToNameNode(symbolNameNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
         writeTypeCache(node, { type: symbolType }, 0 /* EvaluatorFlags.None */);
     }
     function evaluateTypesForImportFromAs(node) {
@@ -13532,7 +13606,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 symbolType = types_1.UnknownType.create();
             }
         }
-        assignTypeToNameNode(aliasNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
+        assignTypeToNameNode(aliasNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
         writeTypeCache(node, { type: symbolType }, 0 /* EvaluatorFlags.None */);
     }
     function evaluateTypesForMatchStatement(node) {
@@ -13630,9 +13704,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     symbolType = cachedModuleType;
                 }
             }
-            assignTypeToNameNode(symbolNameNode, symbolType, 
-            /* isIncomplete */ false, 
-            /* ignoreEmptyContainers */ false);
+            assignTypeToNameNode(symbolNameNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
             writeTypeCache(node, { type: symbolType }, 0 /* EvaluatorFlags.None */);
         }
     }
@@ -14052,7 +14124,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return;
                 }
                 case 4 /* ParseNodeType.AssignmentExpression */: {
-                    getTypeOfExpression(curNode);
+                    evaluateTypesForExpressionInContext(curNode);
                     return;
                 }
                 case 5 /* ParseNodeType.AugmentedAssignment */: {
@@ -14469,7 +14541,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         types_1.FunctionType.addDefaultParameters(functionType);
-                        functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+                        functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
                         typeArgTypes.push(functionType);
                         typeVarContext.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(functionType));
                         return;
@@ -14497,12 +14569,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             concatTypeArgs.forEach((typeArg, index) => {
                                 if (index === concatTypeArgs.length - 1) {
                                     if ((0, types_1.isParamSpec)(typeArg)) {
-                                        functionType.details.paramSpec = typeArg;
+                                        types_1.FunctionType.addParamSpecVariadics(functionType, typeArg);
                                     }
                                     else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
                                         types_1.FunctionType.addDefaultParameters(functionType);
-                                        functionType.details.flags |=
-                                            32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+                                        functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
                                     }
                                 }
                                 else {
@@ -15865,7 +15936,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // the return type. If a list of args is provided, the inference logic may take
     // into account argument types to infer the return type.
     function getFunctionEffectiveReturnType(type, callSiteInfo, inferTypeIfNeeded = true) {
-        const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type, /* includeInferred */ false);
+        const specializedReturnType = types_1.FunctionType.getEffectiveReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
             const liveTypeVarScopes = (callSiteInfo === null || callSiteInfo === void 0 ? void 0 : callSiteInfo.errorNode)
                 ? ParseTreeUtils.getTypeVarScopesForNode(callSiteInfo === null || callSiteInfo === void 0 ? void 0 : callSiteInfo.errorNode)
@@ -16136,20 +16207,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // and cache the return type if necessary. This needs to be done
                 // prior to specializing.
                 inferReturnTypeIfNecessary(typeResult.type);
-                if (member.isInstanceMember &&
-                    (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0) {
-                    let isGenericNonCallable = false;
-                    (0, typeUtils_1.doForEachSubtype)(typeResult.type, (subtype) => {
-                        if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloadedFunction)(subtype)) {
-                            if ((0, typeUtils_1.requiresSpecialization)(typeResult.type, {
-                                ignoreSelf: true,
-                                ignoreImplicitTypeArgs: true,
-                            })) {
-                                isGenericNonCallable = true;
-                            }
-                        }
-                    });
-                    if (isGenericNonCallable && errorNode) {
+                // Check for ambiguous accesses to attributes with generic types?
+                if (errorNode &&
+                    selfClass &&
+                    (0, types_1.isClass)(selfClass) &&
+                    member.isInstanceMember &&
+                    (0, types_1.isClass)(member.unspecializedClassType) &&
+                    (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0 &&
+                    (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
+                    const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, (0, typeUtils_1.selfSpecializeClass)(selfClass, /* overrideTypeArgs */ true));
+                    if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) &&
+                        !(0, types_1.isOverloadedFunction)(subtype) &&
+                        (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
                     }
                 }
@@ -16331,7 +16400,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     let flags = 0 /* AssignTypeFlags.Default */;
                     if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ &&
                         !isFinalVariableDeclaration(primaryDecl) &&
-                        !types_1.ClassType.isFrozenDataClass(destType)) {
+                        !types_1.ClassType.isDataClassFrozen(destType)) {
                         // Class and instance variables that are mutable need to
                         // enforce invariance. We will exempt variables that are
                         // private or protected, since these are presumably
@@ -16963,7 +17032,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // it's Any.
                 if ((0, types_1.isParamSpec)(srcType) &&
                     (0, types_1.isFunction)(destType) &&
-                    types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
+                    types_1.FunctionType.isGradualCallableForm(destType) &&
                     destType.details.parameters.length <= 2) {
                     return true;
                 }
@@ -17245,7 +17314,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* selfType */ undefined, 
                 /* diag */ undefined, recursionCount);
                 if (boundMethod) {
-                    concreteSrcType = (0, typeUtils_1.removeParamSpecVariadicsFromSignature)(boundMethod);
+                    concreteSrcType = boundMethod;
                 }
             }
             // If it's a class, use the constructor for type compatibility checking.
@@ -17789,13 +17858,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        const boundMethod = getBoundMagicMethod(objType, '__call__', 
-        /* selfType */ undefined, 
-        /* diag */ undefined, recursionCount);
-        if (boundMethod) {
-            return (0, typeUtils_1.removeParamSpecVariadicsFromSignature)(boundMethod);
-        }
-        return undefined;
+        return getBoundMagicMethod(objType, '__call__', /* selfType */ undefined, /* diag */ undefined, recursionCount);
     }
     function assignFunctionParameter(destType, srcType, paramIndex, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         // Handle the special case where the dest type is a synthesized
@@ -17927,17 +17990,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function assignFunction(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) === 0;
         const reverseMatching = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
         flags &= ~64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */;
-        destType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(destType);
-        srcType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(srcType);
+        const destParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(destType);
+        if (destParamSpec) {
+            destType = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(destType);
+        }
+        const srcParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(srcType);
+        if (srcParamSpec) {
+            srcType = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(srcType);
+        }
         const destParamDetails = (0, parameterUtils_1.getParameterListDetails)(destType);
         const srcParamDetails = (0, parameterUtils_1.getParameterListDetails)(srcType);
         adjustSourceParamDetailsForDestVariadic(reverseMatching ? destParamDetails : srcParamDetails, reverseMatching ? srcParamDetails : destParamDetails);
-        const targetIncludesParamSpec = reverseMatching ? !!srcType.details.paramSpec : !!destType.details.paramSpec;
+        const targetIncludesParamSpec = reverseMatching ? !!srcParamSpec : !!destParamSpec;
         const destPositionalCount = (_a = destParamDetails.firstKeywordOnlyIndex) !== null && _a !== void 0 ? _a : destParamDetails.params.length;
         const srcPositionalCount = (_b = srcParamDetails.firstKeywordOnlyIndex) !== null && _b !== void 0 ? _b : srcParamDetails.params.length;
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
@@ -18025,7 +18094,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 canAssign = false;
             }
         }
-        if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
+        if (!types_1.FunctionType.isGradualCallableForm(destType) &&
             destParamDetails.firstPositionOrKeywordIndex < srcParamDetails.positionOnlyParamCount &&
             !targetIncludesParamSpec) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.argsPositionOnly().format({
@@ -18061,7 +18130,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     continue;
                 }
-                // If the source parameter is also addressible by keyword, it is OK
+                // If the source parameter is also addressable by keyword, it is OK
                 // that there is no matching positional parameter in the dest.
                 if (srcParam.kind === parameterUtils_1.ParameterKind.Standard) {
                     continue;
@@ -18128,7 +18197,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // their types are compatible.
         if (srcParamDetails.argsIndex !== undefined &&
             destParamDetails.argsIndex !== undefined &&
-            !types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType)) {
+            !types_1.FunctionType.isGradualCallableForm(destType)) {
             let destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
             let srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
             if (!(0, types_1.isUnpacked)(destArgsType)) {
@@ -18143,9 +18212,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the dest has an "*args" but the source doesn't, report the incompatibility.
         // The converse situation is OK.
-        if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
+        if (!types_1.FunctionType.isGradualCallableForm(destType) &&
             srcParamDetails.argsIndex === undefined &&
-            srcType.details.paramSpec === undefined &&
+            srcParamSpec === undefined &&
             destParamDetails.argsIndex !== undefined &&
             !destParamDetails.hasUnpackedVariadicTypeVar) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.argsParamMissing().format({
@@ -18260,9 +18329,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // If the dest has a "**kwargs" but the source doesn't, report the incompatibility.
             // The converse situation is OK.
-            if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
+            if (!types_1.FunctionType.isGradualCallableForm(destType) &&
                 srcParamDetails.kwargsIndex === undefined &&
-                srcType.details.paramSpec === undefined &&
+                srcParamSpec === undefined &&
                 destParamDetails.kwargsIndex !== undefined) {
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.kwargsParamMissing().format({
                     paramName: destParamDetails.params[destParamDetails.kwargsIndex].param.name,
@@ -18272,8 +18341,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the source and the dest are using the same ParamSpec, any additional
         // concatenated parameters must match.
-        if (targetIncludesParamSpec &&
-            ((_j = srcType.details.paramSpec) === null || _j === void 0 ? void 0 : _j.nameWithScope) === ((_k = destType.details.paramSpec) === null || _k === void 0 ? void 0 : _k.nameWithScope)) {
+        if (targetIncludesParamSpec && (srcParamSpec === null || srcParamSpec === void 0 ? void 0 : srcParamSpec.nameWithScope) === (destParamSpec === null || destParamSpec === void 0 ? void 0 : destParamSpec.nameWithScope)) {
             if (srcParamDetails.params.length !== destParamDetails.params.length) {
                 canAssign = false;
             }
@@ -18288,9 +18356,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         // Are we assigning to a function with a ParamSpec?
         if (targetIncludesParamSpec) {
-            const effectiveDestType = reverseMatching ? srcType : destType;
             const effectiveSrcType = reverseMatching ? destType : srcType;
-            if (effectiveDestType.details.paramSpec) {
+            const effectiveDestType = reverseMatching ? srcType : destType;
+            const effectiveSrcParamSpec = reverseMatching ? destParamSpec : srcParamSpec;
+            const effectiveDestParamSpec = reverseMatching ? srcParamSpec : destParamSpec;
+            if (effectiveDestParamSpec) {
                 const requiredMatchParamCount = effectiveDestType.details.parameters.filter((p) => {
                     if (!p.name) {
                         return false;
@@ -18327,13 +18397,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         });
                     }
                 });
-                const srcParamSpec = effectiveSrcType.details.paramSpec;
-                const destParamSpec = effectiveDestType.details.paramSpec;
                 // If there are remaining parameters and the source and dest do not contain
                 // the same ParamSpec, synthesize a function for the remaining parameters.
                 if (remainingParams.length > 0 ||
-                    !srcParamSpec ||
-                    !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true })) {
+                    !effectiveSrcParamSpec ||
+                    !(0, types_1.isTypeSame)(effectiveSrcParamSpec, effectiveDestParamSpec, { ignoreTypeFlags: true })) {
                     const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.details.flags | 64 /* FunctionTypeFlags.SynthesizedMethod */, effectiveSrcType.details.docString);
                     remainingFunction.details.deprecatedMessage = effectiveSrcType.details.deprecatedMessage;
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
@@ -18343,16 +18411,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     remainingParams.forEach((param) => {
                         types_1.FunctionType.addParameter(remainingFunction, param);
                     });
-                    remainingFunction.details.paramSpec = srcParamSpec ? (0, typeUtils_1.convertToInstance)(srcParamSpec) : undefined;
+                    if (effectiveSrcParamSpec) {
+                        types_1.FunctionType.addParamSpecVariadics(remainingFunction, (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec));
+                    }
                     types_1.FunctionType.addHigherOrderTypeVarScopeIds(remainingFunction, effectiveSrcType.details.higherOrderTypeVarScopeIds);
-                    if (!assignType(destParamSpec, remainingFunction, 
+                    if (!assignType(effectiveDestParamSpec, remainingFunction, 
                     /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                         // If we couldn't assign the function to the ParamSpec, see if we can
                         // assign only the ParamSpec. This is possible if there were no
                         // remaining parameters.
                         if (remainingParams.length > 0 ||
-                            !srcParamSpec ||
-                            !assignType((0, typeUtils_1.convertToInstance)(destParamSpec), (0, typeUtils_1.convertToInstance)(srcParamSpec), 
+                            !effectiveSrcParamSpec ||
+                            !assignType((0, typeUtils_1.convertToInstance)(effectiveDestParamSpec), (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec), 
                             /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                             canAssign = false;
                         }
@@ -18473,13 +18543,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // When a value is assigned to a variable with a declared type,
     // we may be able to narrow the type based on the assignment.
-    function narrowTypeBasedOnAssignment(node, declaredType, assignedType) {
-        // TODO: The rules for narrowing types on assignment are defined in
+    function narrowTypeBasedOnAssignment(node, declaredType, assignedTypeResult) {
+        // TODO: The rules for narrowing types on assignment are not defined in
         // the typing spec. Pyright's current logic is currently not even internally
         // consistent and probably not sound from a type theory perspective. It
         // should be completely reworked once there has been a public discussion
         // about the correct behavior.
-        const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedType, (assignedSubtype) => {
+        // If the result is incomplete, do not attempt to narrow the type.
+        if (assignedTypeResult.isIncomplete) {
+            return assignedTypeResult;
+        }
+        const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedTypeResult.type, (assignedSubtype) => {
             // Handle the special case where the assigned type is a literal type.
             // Some types include very large unions of literal types, and we don't
             // want to use an n^2 loop to compare them.
@@ -18541,12 +18615,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // with the declared type. In strict mode, this will retain the "unknown type"
         // diagnostics while still providing reasonable completion suggestions.
         if ((0, typeUtils_1.isIncompleteUnknown)(narrowedType)) {
-            return narrowedType;
+            return { type: narrowedType };
         }
         else if ((0, types_1.isUnknown)(narrowedType)) {
-            return (0, types_1.combineTypes)([narrowedType, declaredType]);
+            return { type: (0, types_1.combineTypes)([narrowedType, declaredType]) };
         }
-        return narrowedType;
+        return { type: narrowedType };
     }
     function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         // If we're overriding a non-method with a method, report it as an error.
@@ -18676,8 +18750,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const baseParamDetails = (0, parameterUtils_1.getParameterListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParameterListDetails)(overrideMethod);
         let canOverride = true;
-        if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(baseMethod) &&
-            !types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(overrideMethod)) {
+        if (!types_1.FunctionType.isGradualCallableForm(baseMethod) && !types_1.FunctionType.isGradualCallableForm(overrideMethod)) {
             // Verify that we're not overriding a static, class or instance method with
             // an incompatible type.
             if (types_1.FunctionType.isStaticMethod(baseMethod)) {
@@ -19137,7 +19210,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         memberTypeFirstParam.hasDeclaredType) {
                         if (subDiag) {
                             subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
-                                type: printType(baseType),
+                                type: printType(firstParamType),
                                 methodName: memberType.details.name || '<anonymous>',
                                 paramName: memberTypeFirstParam.name,
                             }));
@@ -19151,7 +19224,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // evaluating (and caching) the inferred return type if there is no defined return type.
         getFunctionEffectiveReturnType(memberType);
         const specializedFunction = (0, typeUtils_1.applySolvedTypeVars)(memberType, typeVarContext);
-        return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType, (0, typeUtils_1.getTypeVarScopeId)(baseType));
+        // If this is a constructor method, provide the base type's TypeVar scope ID
+        // so any TypeVars in this type can be solved.
+        let baseTypeTypeVarScopeId;
+        if (types_1.FunctionType.isConstructorMethod(specializedFunction) || specializedFunction.details.name === '__init__') {
+            baseTypeTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(baseType);
+        }
+        return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType, baseTypeTypeVarScopeId);
     }
     function isFinalVariable(symbol) {
         return symbol.getDeclarations().some((decl) => isFinalVariableDeclaration(decl));