@zzzen/pyright-internal 1.2.0-dev.20240526 → 1.2.0-dev.20240609

package/dist/analyzer/typeEvaluator.js

@@ -183,27 +183,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let expectedTypeCache = new Map();
     let deferredClassCompletions = [];
     let cancellationToken;
-    let isBasicTypesInitialized = false;
-    let noneClassType;
-    let noneType;
-    let objectType;
-    let typeClassType;
-    let unionClassType;
-    let awaitableProtocolType;
-    let functionObj;
-    let tupleClassType;
-    let boolClassType;
-    let intClassType;
-    let strClassType;
-    let dictClassType;
-    let typedDictClassType;
-    let typedDictPrivateClassType;
-    let supportsKeysAndGetItemProtocolType;
-    let mappingType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
+    let isPrefetchedTypesInitialized = false;
+    // Various types prefetched from stdlib stubs
+    let noneTypeClass;
+    let objectClass;
+    let typeClass;
+    let unionTypeClass;
+    let awaitableClass;
+    let functionClass;
+    let tupleClass;
+    let boolClass;
+    let intClass;
+    let strClass;
+    let dictClass;
+    let typedDictPrivateClass;
+    let supportsKeysAndGetItemClass;
+    let mappingClass;
     function runWithCancellationToken(token, callback) {
         try {
             cancellationToken = token;
@@ -383,7 +382,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // type of surrounding statements to be evaluated.
     function getType(node) {
         var _a, _b;
-        initializedBasicTypes(node);
+        initializePrefetchedTypes(node);
         let type = (_a = evaluateTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
@@ -456,50 +455,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
-    function initializedBasicTypes(node) {
+    function initializePrefetchedTypes(node) {
         var _a;
-        if (!isBasicTypesInitialized) {
+        if (!isPrefetchedTypesInitialized) {
             // Some of these types have cyclical dependencies on each other,
             // so don't re-enter this block once we start executing it.
-            isBasicTypesInitialized = true;
-            objectType = getBuiltInObject(node, 'object');
-            typeClassType = getBuiltInType(node, 'type');
-            functionObj = getBuiltInObject(node, 'function');
-            unionClassType = getTypesType(node, 'UnionType');
-            if (unionClassType && (0, types_1.isClass)(unionClassType)) {
-                unionClassType.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
+            isPrefetchedTypesInitialized = true;
+            objectClass = getBuiltInType(node, 'object');
+            typeClass = getBuiltInType(node, 'type');
+            functionClass = getBuiltInType(node, 'function');
+            unionTypeClass = getTypesType(node, 'UnionType');
+            if (unionTypeClass && (0, types_1.isClass)(unionTypeClass)) {
+                unionTypeClass.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
             }
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
             getTypingType(node, 'Collection');
-            noneClassType = (_a = getTypeshedType(node, 'NoneType')) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
-            noneType = (0, types_1.isInstantiableClass)(noneClassType)
-                ? types_1.ClassType.cloneAsInstance(noneClassType)
-                : types_1.UnknownType.create();
-            tupleClassType = getBuiltInType(node, 'tuple');
-            boolClassType = getBuiltInType(node, 'bool');
-            intClassType = getBuiltInType(node, 'int');
-            strClassType = getBuiltInType(node, 'str');
-            dictClassType = getBuiltInType(node, 'dict');
-            typedDictClassType = getTypingType(node, 'TypedDict');
-            typedDictPrivateClassType = getTypingType(node, '_TypedDict');
-            awaitableProtocolType = getTypingType(node, 'Awaitable');
-            mappingType = getTypingType(node, 'Mapping');
-            supportsKeysAndGetItemProtocolType = getTypeshedType(node, 'SupportsKeysAndGetItem');
-            if (!supportsKeysAndGetItemProtocolType) {
+            noneTypeClass = (_a = getTypeshedType(node, 'NoneType')) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+            tupleClass = getBuiltInType(node, 'tuple');
+            boolClass = getBuiltInType(node, 'bool');
+            intClass = getBuiltInType(node, 'int');
+            strClass = getBuiltInType(node, 'str');
+            dictClass = getBuiltInType(node, 'dict');
+            typedDictPrivateClass = getTypingType(node, '_TypedDict');
+            awaitableClass = getTypingType(node, 'Awaitable');
+            mappingClass = getTypingType(node, 'Mapping');
+            supportsKeysAndGetItemClass = getTypeshedType(node, 'SupportsKeysAndGetItem');
+            if (!supportsKeysAndGetItemClass) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
-                supportsKeysAndGetItemProtocolType = mappingType;
+                supportsKeysAndGetItemClass = mappingClass;
             }
             // Wire up the `Any` class to the special-form version of our internal AnyType.
-            const objectClass = getBuiltInType(node, 'object');
-            if (objectClass &&
-                (0, types_1.isInstantiableClass)(objectClass) &&
-                typeClassType &&
-                (0, types_1.isInstantiableClass)(typeClassType)) {
+            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 */, 
                 /* typeSourceId */ -1, 
                 /* declaredMetaclass */ undefined, 
-                /* effectiveMetaclass */ typeClassType);
+                /* effectiveMetaclass */ typeClass);
                 anyClass.details.baseClasses.push(objectClass);
                 (0, typeUtils_1.computeMroLinearization)(anyClass);
                 const anySpecialForm = types_1.AnyType.createSpecialForm();
@@ -546,7 +537,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // typeshed stubs, do so here. It would be better to fetch this when it's
         // needed in assignType, but we don't have access to the parse tree
         // at that point.
-        initializedBasicTypes(node);
+        initializePrefetchedTypes(node);
         let typeResult = getTypeOfExpressionCore(node, flags, inferenceContext, signatureTracker);
         // Should we disable type promotions for bytes?
         if ((0, types_1.isInstantiableClass)(typeResult.type) &&
@@ -605,7 +596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeResult = getTypeOfMemberAccess(node, flags);
                 break;
             }
-            case 24 /* ParseNodeType.Index */: {
+            case 27 /* ParseNodeType.Index */: {
                 typeResult = getTypeOfIndex(node, flags);
                 break;
             }
@@ -617,7 +608,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeResult = getTypeOfTuple(node, flags, inferenceContext, signatureTracker);
                 break;
             }
-            case 11 /* ParseNodeType.Constant */: {
+            case 14 /* ParseNodeType.Constant */: {
                 typeResult = getTypeOfConstant(node, flags);
                 break;
             }
@@ -635,7 +626,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeResult = getTypeOfNumber(node, typeResult);
                 break;
             }
-            case 18 /* ParseNodeType.Ellipsis */: {
+            case 21 /* ParseNodeType.Ellipsis */: {
                 typeResult = getTypeOfEllipsis(flags, typeResult, node);
                 break;
             }
@@ -657,7 +648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeResult = (0, operations_1.getTypeOfAugmentedAssignment)(evaluatorInterface, node, inferenceContext);
                 break;
             }
-            case 31 /* ParseNodeType.List */:
+            case 34 /* ParseNodeType.List */:
             case 45 /* ParseNodeType.Set */: {
                 typeResult = getTypeOfListOrSet(node, flags, inferenceContext);
                 break;
@@ -674,21 +665,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeResult = (0, operations_1.getTypeOfTernaryOperation)(evaluatorInterface, node, flags, inferenceContext);
                 break;
             }
-            case 32 /* ParseNodeType.ListComprehension */: {
-                typeResult = getTypeOfListComprehension(node, flags, inferenceContext);
+            case 11 /* ParseNodeType.Comprehension */: {
+                typeResult = getTypeOfComprehension(node, flags, inferenceContext);
                 break;
             }
-            case 15 /* ParseNodeType.Dictionary */: {
+            case 18 /* ParseNodeType.Dictionary */: {
                 typeResult = getTypeOfDictionary(node, flags, inferenceContext);
                 break;
             }
-            case 30 /* ParseNodeType.Lambda */: {
+            case 33 /* ParseNodeType.Lambda */: {
                 typeResult = getTypeOfLambda(node, inferenceContext);
                 break;
             }
             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;
@@ -698,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 */: {
@@ -724,7 +714,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 49 /* ParseNodeType.String */:
-            case 27 /* ParseNodeType.FormatString */: {
+            case 30 /* ParseNodeType.FormatString */: {
                 typeResult = getTypeOfString(node);
                 break;
             }
@@ -946,7 +936,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
             const isBytes = (node.strings[0].token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
             // Don't create a literal type if it's an f-string.
-            if (node.strings.some((str) => str.nodeType === 27 /* ParseNodeType.FormatString */)) {
+            if (node.strings.some((str) => str.nodeType === 30 /* ParseNodeType.FormatString */)) {
                 if (isLiteralString) {
                     const literalStringType = getTypingType(node, 'LiteralString');
                     if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
@@ -974,7 +964,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let typeResult;
         let isIncomplete = false;
         // Don't create a literal type if it's an f-string.
-        if (node.nodeType === 27 /* ParseNodeType.FormatString */) {
+        if (node.nodeType === 30 /* ParseNodeType.FormatString */) {
             let isLiteralString = true;
             // If all of the format expressions are of type LiteralString, then
             // the resulting formatted string is also LiteralString.
@@ -1040,8 +1030,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
                     // Handle "LiteralString" specially.
-                    if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
-                        let strInstance = types_1.ClassType.cloneAsInstance(strClassType);
+                    if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
+                        let strInstance = types_1.ClassType.cloneAsInstance(strClass);
                         if (subtype.condition) {
                             strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
                         }
@@ -1280,9 +1270,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.
@@ -1316,9 +1313,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.
@@ -1733,7 +1737,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 break;
             }
-            case 24 /* ParseNodeType.Index */: {
+            case 27 /* ParseNodeType.Index */: {
                 const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* EvaluatorFlags.IndexBaseDefaults */).type);
                 if (baseType && (0, types_1.isClassInstance)(baseType)) {
                     const setItemType = getBoundMagicMethod(baseType, '__setitem__');
@@ -1786,12 +1790,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // (object that provides an __await__ that returns a generator object).
     // If errorNode is undefined, no errors are reported.
     function getTypeOfAwaitable(type, errorNode) {
-        if (!awaitableProtocolType ||
-            !(0, types_1.isInstantiableClass)(awaitableProtocolType) ||
-            awaitableProtocolType.details.typeParameters.length !== 1) {
+        if (!awaitableClass ||
+            !(0, types_1.isInstantiableClass)(awaitableClass) ||
+            awaitableClass.details.typeParameters.length !== 1) {
             return types_1.UnknownType.create();
         }
-        const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(awaitableProtocolType);
+        const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(awaitableClass);
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
@@ -1852,8 +1856,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
                         const getItemReturnType = getTypeOfMagicMethodCall(subtype, '__getitem__', [
                             {
-                                type: intClassType && (0, types_1.isInstantiableClass)(intClassType)
-                                    ? types_1.ClassType.cloneAsInstance(intClassType)
+                                type: intClass && (0, types_1.isInstantiableClass)(intClass)
+                                    ? types_1.ClassType.cloneAsInstance(intClass)
                                     : types_1.UnknownType.create(),
                             },
                         ], errorNode);
@@ -1882,7 +1886,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 // know anything more about them.
                                 nextReturnType = (0, typeUtils_1.mapSubtypes)(nextReturnType, (returnSubtype) => {
                                     if ((0, types_1.isTypeVar)(returnSubtype) && (0, types_1.isUnpackedVariadicTypeVar)(returnSubtype)) {
-                                        return objectType !== null && objectType !== void 0 ? objectType : types_1.UnknownType.create();
+                                        return getObjectType();
                                     }
                                     return returnSubtype;
                                 });
@@ -1983,21 +1987,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return isTypeHashable;
     }
     function getTypedDictClassType() {
-        return typedDictPrivateClassType && (0, types_1.isInstantiableClass)(typedDictPrivateClassType)
-            ? typedDictPrivateClassType
-            : undefined;
+        return typedDictPrivateClass && (0, types_1.isInstantiableClass)(typedDictPrivateClass) ? typedDictPrivateClass : undefined;
     }
     function getTupleClassType() {
-        return tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType) ? tupleClassType : undefined;
+        return tupleClass && (0, types_1.isInstantiableClass)(tupleClass) ? tupleClass : undefined;
     }
     function getObjectType() {
-        return objectType !== null && objectType !== void 0 ? objectType : types_1.UnknownType.create();
+        return objectClass ? (0, typeUtils_1.convertToInstance)(objectClass) : types_1.UnknownType.create();
     }
     function getNoneType() {
-        return noneType !== null && noneType !== void 0 ? noneType : types_1.UnknownType.create();
+        return noneTypeClass ? (0, typeUtils_1.convertToInstance)(noneTypeClass) : types_1.UnknownType.create();
     }
     function getUnionClassType() {
-        return unionClassType !== null && unionClassType !== void 0 ? unionClassType : types_1.UnknownType.create();
+        return unionTypeClass !== null && unionTypeClass !== void 0 ? unionTypeClass : types_1.UnknownType.create();
     }
     function getTypingType(node, symbolName) {
         var _a;
@@ -2022,18 +2024,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return getEffectiveTypeOfSymbol(symbol);
     }
     function checkCodeFlowTooComplex(node) {
-        const scopeNode = node.nodeType === 28 /* ParseNodeType.Function */ ? node : ParseTreeUtils.getExecutionScopeNode(node);
+        const scopeNode = node.nodeType === 31 /* ParseNodeType.Function */ ? node : ParseTreeUtils.getExecutionScopeNode(node);
         const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(scopeNode);
         if (codeComplexity > exports.maxCodeComplexity) {
             let errorRange = scopeNode;
-            if (scopeNode.nodeType === 28 /* ParseNodeType.Function */) {
+            if (scopeNode.nodeType === 31 /* ParseNodeType.Function */) {
                 errorRange = scopeNode.name;
             }
             else if (scopeNode.nodeType === 36 /* ParseNodeType.Module */) {
                 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;
@@ -2099,7 +2101,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // of a Literal['xxx'] statement. If so, we will not treat
     // the string as a normal forward-declared type annotation.
     function isAnnotationLiteralValue(node) {
-        if (node.parent && node.parent.nodeType === 24 /* ParseNodeType.Index */) {
+        if (node.parent && node.parent.nodeType === 27 /* ParseNodeType.Index */) {
             const baseType = getTypeOfExpression(node.parent.baseExpression).type;
             if (baseType && (0, types_1.isInstantiableClass)(baseType)) {
                 if (types_1.ClassType.isSpecialBuiltIn(baseType, 'Literal')) {
@@ -2174,7 +2176,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;
         }
@@ -2195,7 +2198,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);
@@ -2222,18 +2225,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.
@@ -2241,7 +2244,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 {
@@ -2274,12 +2277,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);
@@ -2292,14 +2295,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
@@ -2320,7 +2321,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 */);
@@ -2328,14 +2329,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);
@@ -2405,21 +2406,21 @@ 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) {
-        const targetExpressions = target.nodeType === 31 /* ParseNodeType.List */ ? target.entries : target.expressions;
+    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);
         for (let i = 0; i < targetExpressions.length; i++) {
@@ -2429,9 +2430,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);
@@ -2453,7 +2454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (sourceEntryTypes.length > targetTypes.length) {
                         const removedEntries = sourceEntryTypes.splice(targetUnpackIndex, sourceEntryTypes.length - targetTypes.length + 1);
                         let combinedTypes = (0, types_1.combineTypes)(removedEntries);
-                        if (target.nodeType === 31 /* ParseNodeType.List */) {
+                        if (target.nodeType === 34 /* ParseNodeType.List */) {
                             combinedTypes = stripLiteralValue(combinedTypes);
                         }
                         sourceEntryTypes.splice(targetUnpackIndex, 0, combinedTypes);
@@ -2470,7 +2471,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Have we accounted for all of the targets and sources? If not, we have a size mismatch.
                 if (sourceEntryTypes.length !== targetExpressions.length) {
                     const subDiag = diagAddendum.createAddendum();
-                    subDiag.addMessage((target.nodeType === 31 /* ParseNodeType.List */
+                    subDiag.addMessage((target.nodeType === 34 /* ParseNodeType.List */
                         ? localize_1.LocAddendum.listAssignmentMismatch()
                         : localize_1.LocAddendum.tupleAssignmentMismatch()).format({
                         type: printType(subtype),
@@ -2486,17 +2487,18 @@ 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)));
                 }
             }
         });
         if (!diagAddendum.isEmpty()) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, (target.nodeType === 31 /* ParseNodeType.List */
+            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
@@ -2504,9 +2506,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) {
@@ -2542,22 +2545,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // TypeVar, only the conditions that match the filter will be included.
     function makeTopLevelTypeVarsConcrete(type, makeParamSpecsConcrete = false, conditionFilter) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            var _a, _b;
+            var _a;
             if ((0, types_1.isParamSpec)(subtype)) {
                 if (subtype.paramSpecAccess === 'args') {
-                    if (objectType && (0, types_1.isClassInstance)(objectType)) {
-                        return makeTupleObject([{ type: objectType, isUnbounded: true }]);
-                    }
-                    return types_1.UnknownType.create();
+                    return makeTupleObject([{ type: getObjectType(), isUnbounded: true }]);
                 }
                 else if (subtype.paramSpecAccess === 'kwargs') {
-                    if (dictClassType &&
-                        (0, types_1.isInstantiableClass)(dictClassType) &&
-                        strClassType &&
-                        (0, types_1.isInstantiableClass)(strClassType) &&
-                        objectType &&
-                        (0, types_1.isClassInstance)(objectType)) {
-                        return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictClassType, [(0, typeUtils_1.convertToInstance)(strClassType), objectType], 
+                    if (dictClass && (0, types_1.isInstantiableClass)(dictClass) && strClass && (0, types_1.isInstantiableClass)(strClass)) {
+                        return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictClass, [(0, typeUtils_1.convertToInstance)(strClass), getObjectType()], 
                         /* isTypeArgumentExplicit */ true));
                     }
                     return types_1.UnknownType.create();
@@ -2565,28 +2560,27 @@ 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.
                 if (subtype.isVariadicInUnion) {
                     if (types_1.TypeBase.isInstantiable(subtype)) {
-                        if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
-                            return typeClassType;
+                        if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
+                            return typeClass;
                         }
                     }
-                    else if (objectType) {
-                        return objectType;
+                    else {
+                        return getObjectType();
                     }
                     return types_1.AnyType.create();
                 }
                 // Fall back to "*tuple[object, ...]".
-                return makeTupleObject([{ type: objectType !== null && objectType !== void 0 ? objectType : types_1.UnknownType.create(), isUnbounded: true }], 
-                /* isUnpacked */ true);
+                return makeTupleObject([{ type: getObjectType(), isUnbounded: true }], /* isUnpacked */ true);
             }
             if ((0, types_1.isTypeVar)(subtype)) {
                 // If this is a recursive type alias placeholder
@@ -2619,7 +2613,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return types_1.AnyType.create();
                 }
                 // Fall back to a bound of "object" if no bound is provided.
-                let boundType = (_b = (_a = subtype.details.boundType) !== null && _a !== void 0 ? _a : objectType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                let boundType = (_a = subtype.details.boundType) !== null && _a !== void 0 ? _a : getObjectType();
                 boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
                 return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
             }
@@ -2739,9 +2733,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) &&
@@ -2749,13 +2743,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);
                     }
                 }
@@ -2764,30 +2759,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 24 /* ParseNodeType.Index */: {
+            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 31 /* ParseNodeType.List */:
+            case 34 /* ParseNodeType.List */:
             case 52 /* ParseNodeType.Tuple */: {
-                assignTypeToTupleOrListNode(target, type, isTypeIncomplete, srcExpr);
+                assignTypeToTupleOrListNode(target, typeResult, srcExpr);
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
@@ -2802,23 +2799,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;
             }
@@ -2912,7 +2911,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 writeTypeCache(node, resultToCache, 0 /* EvaluatorFlags.None */);
                 break;
             }
-            case 24 /* ParseNodeType.Index */: {
+            case 27 /* ParseNodeType.Index */: {
                 const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* EvaluatorFlags.IndexBaseDefaults */);
                 getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* EvaluatorFlags.None */);
                 writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* EvaluatorFlags.None */);
@@ -3162,8 +3161,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Find the parse node associated with the scope that is just inside of the
             // scope that declares the captured variable.
             const innerScopeNode = ScopeUtils.findTopNodeInScope(node, scopeHierarchy[scopeHierarchy.length - 2]);
-            if ((innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 28 /* ParseNodeType.Function */ ||
-                (innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 30 /* ParseNodeType.Lambda */ ||
+            if ((innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 31 /* ParseNodeType.Function */ ||
+                (innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 33 /* ParseNodeType.Lambda */ ||
                 (innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 10 /* ParseNodeType.Class */) {
                 const innerScopeCodeFlowNode = AnalyzerNodeInfo.getFlowNode(innerScopeNode);
                 if (innerScopeCodeFlowNode) {
@@ -3236,7 +3235,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             const memberName = node.parent.memberName.value;
                             if (memberName === 'args' || memberName === 'kwargs') {
                                 const outerFunctionScope = ParseTreeUtils.getEnclosingClassOrFunction(enclosingScope);
-                                if ((outerFunctionScope === null || outerFunctionScope === void 0 ? void 0 : outerFunctionScope.nodeType) === 28 /* ParseNodeType.Function */) {
+                                if ((outerFunctionScope === null || outerFunctionScope === void 0 ? void 0 : outerFunctionScope.nodeType) === 31 /* ParseNodeType.Function */) {
                                     enclosingScope = outerFunctionScope;
                                 }
                                 else if (!scopedTypeVarInfo.type.scopeId) {
@@ -3256,7 +3255,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     container: enclosingScope.name.value,
                                 }), node);
                             }
-                            type = types_1.TypeVarType.cloneForScopeId(type, ParseTreeUtils.getScopeIdForNode(enclosingScope), enclosingScope.name.value, enclosingScope.nodeType === 28 /* ParseNodeType.Function */
+                            type = types_1.TypeVarType.cloneForScopeId(type, ParseTreeUtils.getScopeIdForNode(enclosingScope), enclosingScope.name.value, enclosingScope.nodeType === 31 /* ParseNodeType.Function */
                                 ? 1 /* TypeVarScopeType.Function */
                                 : 0 /* TypeVarScopeType.Class */);
                         }
@@ -3327,7 +3326,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (param.details.isDefaultExplicit || param.details.isParamSpec) {
                     defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
                 }
-                else if (param.details.isVariadic && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                else if (param.details.isVariadic && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
                     defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
                     /* isUnpackedTuple */ true);
                 }
@@ -3367,7 +3366,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 scopeUsesTypeParameterSyntax = !!curNode.typeParameters;
                 nestedClassCount++;
             }
-            else if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+            else if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
                 const functionType = getTypeOfFunctionPredecorated(curNode);
                 if (functionType) {
                     const functionDetails = functionType.details;
@@ -3731,8 +3730,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // be reported elsewhere.
                         return undefined;
                     }
-                    if ((0, typeUtils_1.isNoneInstance)(subtype) && noneType && (0, types_1.isClassInstance)(noneType)) {
-                        const typeResult = getTypeOfBoundMember(node.memberName, noneType, memberName, usage, diag);
+                    if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+                        (0, debug_1.assert)((0, types_1.isClassInstance)(subtype));
+                        const typeResult = getTypeOfBoundMember(node.memberName, subtype, memberName, usage, diag);
                         if (typeResult && !typeResult.typeErrors) {
                             type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
                             if (typeResult.isIncomplete) {
@@ -3774,7 +3774,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 else {
-                    type = getTypeOfMemberAccessWithBaseType(node, { type: functionObj !== null && functionObj !== void 0 ? functionObj : types_1.AnyType.create() }, usage, flags).type;
+                    type = getTypeOfMemberAccessWithBaseType(node, { type: functionClass ? (0, typeUtils_1.convertToInstance)(functionClass) : types_1.UnknownType.create() }, usage, flags).type;
                 }
                 break;
             }
@@ -4008,7 +4008,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If a Final instance variable is declared in the class body but is
                 // being assigned within an __init__ method, it's allowed.
                 const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(errorNode);
-                if (!enclosingFunctionNode || enclosingFunctionNode.name.value !== '__init__') {
+                if (!enclosingFunctionNode ||
+                    enclosingFunctionNode.name.value !== '__init__' ||
+                    finalVarTypeDecl.inferredTypeSource !== undefined ||
+                    (0, types_1.isInstantiableClass)(classType)) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocMessage.finalReassigned().format({ name: memberName }));
                     isDescriptorError = true;
                 }
@@ -4030,7 +4033,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())) {
@@ -4317,7 +4320,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;
                     }
@@ -4349,7 +4352,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;
                     }
@@ -4392,8 +4395,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         argList.push({
             argumentCategory: 0 /* ArgumentCategory.Simple */,
             typeResult: {
-                type: strClassType && (0, types_1.isInstantiableClass)(strClassType)
-                    ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName)
+                type: strClass && (0, types_1.isInstantiableClass)(strClass)
+                    ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClass), memberName)
                     : types_1.AnyType.create(),
             },
         });
@@ -4715,11 +4718,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 {
@@ -4736,7 +4739,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);
                 }
@@ -4901,17 +4904,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     types_1.ClassType.isPartiallyEvaluated(concreteSubtype);
                 const isFinalAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'Final');
                 const isClassVarAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'ClassVar');
-                // Inlined TypedDicts are supported only for 'dict' (and not for 'Dict').
-                // This feature is currently experimental.
-                const supportsTypedDictTypeArg = AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures &&
-                    types_1.ClassType.isBuiltIn(concreteSubtype, 'dict') &&
-                    !types_1.ClassType.isBuiltIn(concreteSubtype, 'Dict');
                 let typeArgs = getTypeArgs(node, flags, {
                     isAnnotatedClass,
                     hasCustomClassGetItem: hasCustomClassGetItem || !isGenericClass,
                     isFinalAnnotation,
                     isClassVarAnnotation,
-                    supportsTypedDictTypeArg,
                 });
                 if (!isAnnotatedClass) {
                     typeArgs = adjustTypeArgumentsForVariadicTypeVar(typeArgs, concreteSubtype.details.typeParameters, node);
@@ -5059,8 +5056,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
     }
     function makeTupleObject(typeArgs, isUnpackedTuple = false) {
-        if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, typeArgs, /* isTypeArgumentExplicit */ true, isUnpackedTuple));
+        if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
+            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClass, typeArgs, /* isTypeArgumentExplicit */ true, isUnpackedTuple));
         }
         return types_1.UnknownType.create();
     }
@@ -5371,7 +5368,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 };
             }
             else {
-                typeResult = getTypeArg(expr, adjFlags, !!(options === null || options === void 0 ? void 0 : options.supportsTypedDictTypeArg) && argIndex === 0);
+                typeResult = getTypeArg(expr, adjFlags);
             }
             return typeResult;
         };
@@ -5415,7 +5412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeArgs;
     }
-    function getTypeArg(node, flags, supportsDictExpression) {
+    function getTypeArg(node, flags) {
         let typeResult;
         let adjustedFlags = flags |
             128 /* EvaluatorFlags.ExpectingInstantiableType */ |
@@ -5425,7 +5422,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (fileInfo.isStubFile) {
             adjustedFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
         }
-        if (node.nodeType === 31 /* ParseNodeType.List */) {
+        if (node.nodeType === 34 /* ParseNodeType.List */) {
             typeResult = {
                 type: types_1.UnknownType.create(),
                 typeList: node.entries.map((entry) => {
@@ -5436,20 +5433,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Set the node's type so it isn't reevaluated later.
             setTypeResultForNode(node, { type: types_1.UnknownType.create() });
         }
-        else if (node.nodeType === 15 /* ParseNodeType.Dictionary */ && supportsDictExpression) {
-            const inlinedTypeDict = typedDictClassType && (0, types_1.isInstantiableClass)(typedDictClassType)
-                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClassType)
-                : undefined;
-            const keyTypeFallback = strClassType && (0, types_1.isInstantiableClass)(strClassType) ? strClassType : types_1.UnknownType.create();
-            typeResult = {
-                type: keyTypeFallback,
-                inlinedTypeDict,
-                node,
-            };
-        }
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
-            if (node.nodeType === 15 /* ParseNodeType.Dictionary */) {
+            if (node.nodeType === 18 /* ParseNodeType.Dictionary */) {
                 addError(localize_1.LocMessage.dictInAnnotation(), node);
             }
             if ((flags & 131072 /* EvaluatorFlags.DisallowClassVar */) !== 0) {
@@ -5525,7 +5511,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
             return undefined;
         }
-        if (!tupleClassType || !(0, types_1.isInstantiableClass)(tupleClassType)) {
+        if (!tupleClass || !(0, types_1.isInstantiableClass)(tupleClass)) {
             return undefined;
         }
         // Build an array of expected types.
@@ -5545,11 +5531,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         else {
-            const tupleTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(tupleClassType));
-            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+            const tupleTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(tupleClass));
+            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
-            const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClassType, tupleTypeVarContext);
+            const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClass, tupleTypeVarContext);
             if (!specializedTuple.typeArguments || specializedTuple.typeArguments.length !== 1) {
                 return undefined;
             }
@@ -5641,7 +5627,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeCallNotAllowed() + diag.getString(), node);
         }
         // Handle immediate calls of lambdas specially.
-        if (node.leftExpression.nodeType === 30 /* ParseNodeType.Lambda */) {
+        if (node.leftExpression.nodeType === 33 /* ParseNodeType.Lambda */) {
             baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
         }
         else {
@@ -5748,7 +5734,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // to determine the lambda's type. It needs to be inferred from the argument
     // types instead.
     function getTypeOfLambdaForCall(node, inferenceContext) {
-        (0, debug_1.assert)(node.leftExpression.nodeType === 30 /* ParseNodeType.Lambda */);
+        (0, debug_1.assert)(node.leftExpression.nodeType === 33 /* ParseNodeType.Lambda */);
         const expectedType = types_1.FunctionType.createSynthesizedInstance('');
         expectedType.details.declaredReturnType = inferenceContext
             ? inferenceContext.expectedType
@@ -5855,24 +5841,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) {
@@ -5882,7 +5870,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             scope = ScopeUtils.getScopeForNode(curNode);
             // Stop when we get a valid scope that's not a list comprehension
             // scope. That includes lambdas, functions, classes, and modules.
-            if (scope && scope.type !== 1 /* ScopeType.ListComprehension */) {
+            if (scope && scope.type !== 1 /* ScopeType.Comprehension */) {
                 break;
             }
             curNode = curNode.parent;
@@ -6058,10 +6046,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if (effectiveTargetClass &&
                 !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
-                !(0, typeUtils_1.derivesFromAnyOrUnknown)(effectiveTargetClass) &&
-                objectType &&
-                (0, types_1.isClassInstance)(objectType)) {
-                resultType = types_1.ClassType.cloneAsInstantiable(objectType);
+                !(0, typeUtils_1.derivesFromAnyOrUnknown)(effectiveTargetClass)) {
+                resultType = objectClass !== null && objectClass !== void 0 ? objectClass : types_1.UnknownType.create();
             }
             else {
                 resultType = types_1.UnknownType.create();
@@ -6102,9 +6088,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(nextBaseClassType) : nextBaseClassType };
                 }
                 // There's not much we can say about the type. Simply return object or type.
-                if (objectType && (0, types_1.isClassInstance)(objectType) && typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
+                if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
                     return {
-                        type: resultIsInstance ? objectType : (0, typeUtils_1.convertToInstance)(typeClassType),
+                        type: resultIsInstance ? getObjectType() : (0, typeUtils_1.convertToInstance)(typeClass),
                     };
                 }
             }
@@ -7063,7 +7049,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If this is a tuple with specified element types, use those
                 // specified types rather than using the more generic iterator
                 // type which will be a union of all element types.
-                const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClassType);
+                const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClass);
                 if ((0, types_1.isClassInstance)(combinedArgType) && (0, typeUtils_1.isTupleClass)(combinedArgType)) {
                     const tupleTypeArgs = (_a = combinedArgType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [];
                     if (tupleTypeArgs.length !== 1 || !tupleTypeArgs[0].isUnbounded) {
@@ -7109,6 +7095,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.
@@ -7134,6 +7121,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;
@@ -7155,16 +7148,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,
@@ -7194,12 +7187,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) {
@@ -7576,13 +7563,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(),
@@ -7592,20 +7578,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     else {
                         const strObjType = getBuiltInObject(errorNode, 'str');
-                        if (supportsKeysAndGetItemProtocolType &&
-                            (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType) &&
+                        if (supportsKeysAndGetItemClass &&
+                            (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass) &&
                             strObjType &&
                             (0, types_1.isClassInstance)(strObjType)) {
-                            const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemProtocolType));
+                            const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemClass));
                             let isValidMappingType = false;
                             // If this was a TypeVar (e.g. for pseudo-generic classes),
                             // don't emit this error.
                             if ((0, types_1.isTypeVar)(argType)) {
                                 isValidMappingType = true;
                             }
-                            else if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemProtocolType), argType, 
+                            else if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), argType, 
                             /* diag */ undefined, mappingTypeVarContext)) {
-                                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemProtocolType, mappingTypeVarContext);
+                                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemClass, mappingTypeVarContext);
                                 const typeArgs = specializedMapping.typeArguments;
                                 if (typeArgs && typeArgs.length >= 2) {
                                     if (assignType(strObjType, typeArgs[0])) {
@@ -7720,17 +7706,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(),
@@ -7939,7 +7925,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);
@@ -8030,6 +8016,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);
@@ -8050,7 +8037,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             // The type annotation for the "self" parameter in an __init__ method to
-            // can incluence the type being constructed.
+            // can influence the type being constructed.
             if (type.details.name === '__init__' &&
                 type.strippedFirstParamType &&
                 type.boundToType &&
@@ -8159,14 +8146,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;
                     }
                 }
@@ -8182,10 +8169,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;
@@ -8252,7 +8239,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             types_1.ClassType.isBuiltIn(specializedReturnType, ['TypeGuard', 'TypeIs']) &&
             specializedReturnType.typeArguments &&
             specializedReturnType.typeArguments.length > 0) {
-            if (boolClassType && (0, types_1.isInstantiableClass)(boolClassType)) {
+            if (boolClass && (0, types_1.isInstantiableClass)(boolClass)) {
                 let typeGuardType = specializedReturnType.typeArguments[0];
                 // If the first argument is a simple (non-constrained) TypeVar,
                 // associate that TypeVar with the resulting TypeGuard type.
@@ -8267,7 +8254,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 const useTypeIsSemantics = types_1.ClassType.isBuiltIn(specializedReturnType, 'TypeIs');
-                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useTypeIsSemantics));
+                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClass, typeGuardType, useTypeIsSemantics));
             }
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
@@ -8408,39 +8395,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] };
@@ -8473,7 +8463,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, {
@@ -8990,12 +8980,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getParamSpecDefaultType(node, isPep695Syntax) {
         const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
-        if (node.nodeType === 18 /* ParseNodeType.Ellipsis */) {
+        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 === 31 /* ParseNodeType.List */) {
+        if (node.nodeType === 34 /* ParseNodeType.List */) {
             node.entries.forEach((paramExpr, index) => {
                 const typeResult = getTypeOfExpressionExpectingType(paramExpr, {
                     allowTypeVarsWithoutScopeId: true,
@@ -9026,7 +9016,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) &&
@@ -9125,7 +9115,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         /* typeParamNodes */ undefined, () => typeParameters);
     }
     function getBooleanValue(node) {
-        if (node.nodeType === 11 /* ParseNodeType.Constant */) {
+        if (node.nodeType === 14 /* ParseNodeType.Constant */) {
             if (node.constType === 15 /* KeywordType.False */) {
                 return false;
             }
@@ -9179,9 +9169,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
         let isBaseClassAny = false;
         if ((0, types_1.isAnyOrUnknown)(baseClass)) {
-            if (objectType && (0, types_1.isClassInstance)(objectType)) {
-                baseClass = types_1.ClassType.cloneAsInstantiable(objectType);
-            }
+            baseClass = objectClass !== null && objectClass !== void 0 ? objectClass : types_1.UnknownType.create();
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
             isBaseClassAny = true;
         }
@@ -9264,7 +9252,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 classType.details.baseClasses.push(specializedType);
             }
             else {
-                addExpectedClassDiagnostic(typeArg.type, argList[1].valueExpression || errorNode);
+                classType.details.baseClasses.push(types_1.UnknownType.create());
             }
         });
         if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
@@ -9275,7 +9263,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfConstant(node, flags) {
         let type;
         if (node.constType === 26 /* KeywordType.None */) {
-            type = (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0 ? noneClassType : noneType;
+            if (noneTypeClass) {
+                type =
+                    (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0
+                        ? noneTypeClass
+                        : (0, typeUtils_1.convertToInstance)(noneTypeClass);
+            }
         }
         else if (node.constType === 33 /* KeywordType.True */ ||
             node.constType === 15 /* KeywordType.False */ ||
@@ -9346,15 +9339,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return handleSubtype(subtype);
             }
             if ((0, typeUtils_1.isNoneInstance)(subtype)) {
-                if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                if (objectClass && (0, types_1.isInstantiableClass)(objectClass)) {
                     // Use 'object' for 'None'.
-                    return handleSubtype(objectType);
+                    return handleSubtype((0, typeUtils_1.convertToInstance)(objectClass));
                 }
             }
             if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
-                if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
+                if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
                     // Use 'type' for 'type[None]'.
-                    return handleSubtype(types_1.ClassType.cloneAsInstance(typeClassType));
+                    return handleSubtype(types_1.ClassType.cloneAsInstance(typeClass));
                 }
             }
             magicMethodSupported = false;
@@ -9569,9 +9562,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 128 /* EvaluatorFlags.ExpectingInstantiableType */);
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             let addUnknown = true;
-            if (entryNode.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
+            if (entryNode.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, keyFlags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
@@ -9633,11 +9626,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 addUnknown = false;
             }
-            else if (entryNode.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
+            else if (entryNode.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
                 let expectedType;
                 if (expectedKeyType && expectedValueType) {
-                    if (supportsKeysAndGetItemProtocolType && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType)) {
-                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(supportsKeysAndGetItemProtocolType, [expectedKeyType, expectedValueType], 
+                    if (supportsKeysAndGetItemClass && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass)) {
+                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(supportsKeysAndGetItemClass, [expectedKeyType, expectedValueType], 
                         /* isTypeArgumentExplicit */ true));
                     }
                 }
@@ -9661,8 +9654,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else if ((0, types_1.isClassInstance)(unexpandedType) && types_1.ClassType.isTypedDictClass(unexpandedType)) {
                     // Handle dictionary expansion for a TypedDict.
-                    if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
-                        const strObject = types_1.ClassType.cloneAsInstance(strClassType);
+                    if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
+                        const strObject = types_1.ClassType.cloneAsInstance(strClass);
                         const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
                         /* allowNarrowed */ true);
                         tdEntries.knownItems.forEach((entry, name) => {
@@ -9678,20 +9671,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneAsInstance(strObject) });
                             valueTypes.push({
                                 node: entryNode,
-                                type: (_c = (_b = (_a = tdEntries.extraItems) === null || _a === void 0 ? void 0 : _a.valueType) !== null && _b !== void 0 ? _b : objectType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
+                                type: (_b = (_a = tdEntries.extraItems) === null || _a === void 0 ? void 0 : _a.valueType) !== null && _b !== void 0 ? _b : getObjectType(),
                             });
                         }
                         addUnknown = false;
                     }
                 }
-                else if (supportsKeysAndGetItemProtocolType &&
-                    (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType)) {
-                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemProtocolType));
-                    supportsKeysAndGetItemProtocolType = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemProtocolType);
-                    if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemProtocolType), unexpandedType, 
+                else if (supportsKeysAndGetItemClass && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass)) {
+                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemClass));
+                    supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemClass);
+                    if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), unexpandedType, 
                     /* diag */ undefined, mappingTypeVarContext, 
                     /* srcTypeVarContext */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
-                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemProtocolType, mappingTypeVarContext);
+                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemClass, mappingTypeVarContext);
                         const typeArgs = specializedMapping.typeArguments;
                         if (typeArgs && typeArgs.length >= 2) {
                             if (forceStrictInference || index < maxEntriesToUseForInference) {
@@ -9706,8 +9698,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
             }
-            else if (entryNode.nodeType === 32 /* ParseNodeType.ListComprehension */) {
-                const dictEntryTypeResult = getElementTypeFromListComprehension(entryNode, flags, expectedValueType, expectedKeyType);
+            else if (entryNode.nodeType === 11 /* ParseNodeType.Comprehension */) {
+                const dictEntryTypeResult = getElementTypeFromComprehension(entryNode, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, expectedValueType, expectedKeyType);
                 const dictEntryType = dictEntryTypeResult.type;
                 if (dictEntryTypeResult.isIncomplete) {
                     isIncomplete = true;
@@ -9717,7 +9709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 // The result should be a tuple.
                 if ((0, types_1.isClassInstance)(dictEntryType) && (0, typeUtils_1.isTupleClass)(dictEntryType)) {
-                    const typeArgs = (_d = dictEntryType.tupleTypeArguments) === null || _d === void 0 ? void 0 : _d.map((t) => t.type);
+                    const typeArgs = (_c = dictEntryType.tupleTypeArguments) === null || _c === void 0 ? void 0 : _c.map((t) => t.type);
                     if (typeArgs && typeArgs.length === 2) {
                         if (forceStrictInference || index < maxEntriesToUseForInference) {
                             keyTypes.push({ node: entryNode, type: typeArgs[0] });
@@ -9739,7 +9731,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfListOrSet(node, flags, inferenceContext) {
         var _a;
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0 &&
-            node.nodeType === 31 /* ParseNodeType.List */ &&
+            node.nodeType === 34 /* ParseNodeType.List */ &&
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useListInstead());
@@ -9789,7 +9781,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Attempts to determine the type of a list or set statement based on an expected type.
     // Returns undefined if that type cannot be honored.
     function getTypeOfListOrSetWithContext(node, flags, inferenceContext) {
-        const builtInClassName = node.nodeType === 31 /* ParseNodeType.List */ ? 'list' : 'set';
+        const builtInClassName = node.nodeType === 34 /* ParseNodeType.List */ ? 'list' : 'set';
         inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
         let isIncomplete = false;
         let typeErrors = false;
@@ -9802,8 +9794,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
         node.entries.forEach((entry) => {
             let entryTypeResult;
-            if (entry.nodeType === 32 /* ParseNodeType.ListComprehension */) {
-                entryTypeResult = getElementTypeFromListComprehension(entry, flags, expectedEntryType);
+            if (entry.nodeType === 11 /* ParseNodeType.Comprehension */) {
+                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, expectedEntryType);
             }
             else {
                 entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
@@ -9861,7 +9853,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Attempts to infer the type of a list or set statement with no "expected type".
     function getTypeOfListOrSetInferred(node, flags, hasExpectedType) {
-        const builtInClassName = node.nodeType === 31 /* ParseNodeType.List */ ? 'list' : 'set';
+        const builtInClassName = node.nodeType === 34 /* ParseNodeType.List */ ? 'list' : 'set';
         const verifyHashable = node.nodeType === 45 /* ParseNodeType.Set */;
         let isEmptyContainer = false;
         let isIncomplete = false;
@@ -9869,8 +9861,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let entryTypes = [];
         node.entries.forEach((entry, index) => {
             let entryTypeResult;
-            if (entry.nodeType === 32 /* ParseNodeType.ListComprehension */ && !entry.isGenerator) {
-                entryTypeResult = getElementTypeFromListComprehension(entry, flags);
+            if (entry.nodeType === 11 /* ParseNodeType.Comprehension */ && !entry.isGenerator) {
+                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */);
             }
             else {
                 entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */);
@@ -9977,7 +9969,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);
@@ -10189,14 +10181,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type: functionType, isIncomplete, typeErrors };
     }
-    function getTypeOfListComprehension(node, flags, inferenceContext) {
+    function getTypeOfComprehension(node, flags, inferenceContext) {
         let isIncomplete = false;
         let typeErrors = false;
         // If any of the "for" clauses are marked async or any of the "if" clauses
         // or any clause other than the leftmost "for" contain an "await" operator,
         // it is treated as an async generator.
         let isAsync = node.forIfNodes.some((comp, index) => {
-            if (comp.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ && comp.isAsync) {
+            if (comp.nodeType === 12 /* ParseNodeType.ComprehensionFor */ && comp.isAsync) {
                 return true;
             }
             return index > 0 && ParseTreeUtils.containsAwaitNode(comp);
@@ -10207,7 +10199,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
         const expectedEntryType = getExpectedEntryTypeForIterable(node, builtInIteratorType, inferenceContext);
-        const elementTypeResult = getElementTypeFromListComprehension(node, flags, expectedEntryType);
+        const elementTypeResult = getElementTypeFromComprehension(node, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, expectedEntryType);
         if (elementTypeResult.isIncomplete) {
             isIncomplete = true;
         }
@@ -10251,10 +10243,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    function evaluateListComprehensionForIf(node) {
+    function evaluateComprehensionForIf(node) {
         var _a;
         let isIncomplete = false;
-        if (node.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
+        if (node.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
             const iterableTypeResult = getTypeOfExpression(node.iterableExpression);
             if (iterableTypeResult.isIncomplete) {
                 isIncomplete = true;
@@ -10262,34 +10254,33 @@ 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 === 34 /* ParseNodeType.ListComprehensionIf */);
+            (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;
     }
-    // Returns the type of one entry returned by the list comprehension,
-    // as opposed to the entire list.
-    function getElementTypeFromListComprehension(node, flags, expectedValueOrElementType, expectedKeyType) {
+    // Returns the type of one entry returned by the comprehension.
+    function getElementTypeFromComprehension(node, flags, expectedValueOrElementType, expectedKeyType) {
         let isIncomplete = false;
         let typeErrors = false;
         // "Execute" the list comprehensions from start to finish.
         for (const forIfNode of node.forIfNodes) {
-            if (evaluateListComprehensionForIf(forIfNode)) {
+            if (evaluateComprehensionForIf(forIfNode)) {
                 isIncomplete = true;
             }
         }
         let type = types_1.UnknownType.create();
-        if (node.expression.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
+        if (node.expression.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
             // Create a tuple with the key/value types.
-            const keyTypeResult = getTypeOfExpression(node.expression.keyExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedKeyType));
+            const keyTypeResult = getTypeOfExpression(node.expression.keyExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedKeyType));
             if (keyTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -10300,7 +10291,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!expectedKeyType || !(0, typeUtils_1.containsLiteralType)(expectedKeyType)) {
                 keyType = stripLiteralValue(keyType);
             }
-            const valueTypeResult = getTypeOfExpression(node.expression.valueExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            const valueTypeResult = getTypeOfExpression(node.expression.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
             if (valueTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -10316,12 +10307,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 { type: valueType, isUnbounded: false },
             ]);
         }
-        else if (node.expression.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
+        else if (node.expression.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
             // The parser should have reported an error in this case because it's not allowed.
-            getTypeOfExpression(node.expression.expandExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            getTypeOfExpression(node.expression.expandExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
         }
         else if ((0, parseNodes_1.isExpressionNode)(node)) {
-            const exprTypeResult = getTypeOfExpression(node.expression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            const exprTypeResult = getTypeOfExpression(node.expression, flags, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
             if (exprTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -10404,6 +10395,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);
@@ -10458,10 +10450,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')) {
@@ -10471,11 +10463,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 {
@@ -10511,7 +10503,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;
     }
@@ -10539,9 +10534,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addExpectedClassDiagnostic(typeArg0Type, typeArgs[0].node);
             typeArg0Type = types_1.UnknownType.create();
         }
-        let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
-        if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
-            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionClassType));
+        let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create()]);
+        if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
+            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
         return optionalType;
     }
@@ -10601,7 +10596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'int', itemExpr.value);
                 }
             }
-            else if (itemExpr.nodeType === 11 /* ParseNodeType.Constant */) {
+            else if (itemExpr.nodeType === 14 /* ParseNodeType.Constant */) {
                 if (itemExpr.constType === 33 /* KeywordType.True */) {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'bool', true);
                 }
@@ -10609,7 +10604,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'bool', false);
                 }
                 else if (itemExpr.constType === 26 /* KeywordType.None */) {
-                    type = noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create();
+                    type = noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create();
                 }
             }
             else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
@@ -10653,8 +10648,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             literalTypes.push(type);
         }
         let result = (0, types_1.combineTypes)(literalTypes);
-        if ((0, types_1.isUnion)(result) && unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
-            result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionClassType));
+        if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
+            result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
         return result;
     }
@@ -10900,8 +10895,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() };
@@ -10916,6 +10916,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.
@@ -11048,6 +11088,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         for (const typeArg of typeArgs) {
             let typeArgType = typeArg.type;
+            // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
             if (!validateTypeArg(typeArg, {
                 allowVariadicTypeVar: fileInfo.diagnosticRuleSet.enableExperimentalFeatures,
             })) {
@@ -11059,6 +11100,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // If this is an unpacked tuple, explode out the individual items.
             if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.tupleTypeArguments) {
+                // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
                 if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
                     typeArg.type.tupleTypeArguments.forEach((tupleTypeArg) => {
                         types.push((0, typeUtils_1.convertToInstantiable)(tupleTypeArg.type));
@@ -11072,6 +11114,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else {
                 if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedVariadicTypeVar)(typeArgType)) {
+                    // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
                     if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
                         // If this is an unpacked TypeVar, note that it is in a union so we can
                         // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
@@ -11093,8 +11136,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
         }
         let unionType = (0, types_1.combineTypes)(types);
-        if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
-            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(unionClassType));
+        if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
+            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
         return unionType;
     }
@@ -11144,10 +11187,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);
         }
@@ -11321,7 +11361,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Handle 'LiteralString' specially because we want it to act as
             // though it derives from 'str'.
             if (assignedName === 'LiteralString') {
-                specialType.details.baseClasses.push(strClassType !== null && strClassType !== void 0 ? strClassType : types_1.AnyType.create());
+                specialType.details.baseClasses.push(strClass !== null && strClass !== void 0 ? strClass : types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
             }
             writeTypeCache(node, { type: specialType }, 0 /* EvaluatorFlags.None */);
@@ -11492,7 +11532,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 */);
@@ -11599,7 +11639,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return `__type_of_${paramName}`;
     }
     function getTypeOfClass(node) {
-        initializedBasicTypes(node);
+        initializePrefetchedTypes(node);
         // Is this type already cached?
         const cachedClassType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
         if (cachedClassType) {
@@ -11861,6 +11901,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             classType.details.flags |= 1024 /* 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 */;
@@ -12216,9 +12257,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!classType.details.requiresVarianceInference) {
             return;
         }
-        if (!objectType || !(0, types_1.isClassInstance)(objectType)) {
-            return;
-        }
         // Presumptively mark the variance inference as complete. This
         // prevents potential recursion.
         classType.details.requiresVarianceInference = false;
@@ -12245,8 +12283,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (p.details.isVariadic) {
                     return p;
                 }
-                (0, debug_1.assert)(objectType !== undefined);
-                return i === paramIndex ? objectType : dummyTypeObject;
+                return i === paramIndex ? getObjectType() : dummyTypeObject;
             });
             // Replace all type arguments with a dummy type except for the
             // TypeVar of interest, which is replaced with itself.
@@ -12303,7 +12340,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!effectiveMetaclass || (0, types_1.isInstantiableClass)(effectiveMetaclass)) {
             for (const baseClass of classType.details.baseClasses) {
                 if ((0, types_1.isInstantiableClass)(baseClass)) {
-                    const baseClassMeta = baseClass.details.effectiveMetaclass || typeClassType;
+                    const baseClassMeta = baseClass.details.effectiveMetaclass || typeClass;
                     if (baseClassMeta && (0, types_1.isInstantiableClass)(baseClassMeta)) {
                         // Make sure there is no metaclass conflict.
                         if (!effectiveMetaclass) {
@@ -12536,7 +12573,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
     }
     function getTypeOfFunction(node) {
-        initializedBasicTypes(node);
+        initializePrefetchedTypes(node);
         // Is this predecorated function type cached?
         let functionType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
         if (functionType) {
@@ -12877,7 +12914,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 paramType1.paramSpecAccess === 'args' &&
                 (0, types_1.isParamSpec)(paramType2) &&
                 paramType2.paramSpecAccess === 'kwargs') {
-                functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+                functionType.details.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
             }
         }
         // If the function contains an *args and a **kwargs parameter and both
@@ -12885,7 +12922,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // 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 */;
+            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
@@ -12963,7 +13000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // the type checker should assume that the type is optional (i.e. a union
         // of the specified type and 'None'). Skip this step if the type is already
         // optional to avoid losing alias names when combining the types.
-        if (((_a = param.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 11 /* ParseNodeType.Constant */ &&
+        if (((_a = param.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 14 /* ParseNodeType.Constant */ &&
             param.defaultValue.constType === 26 /* KeywordType.None */ &&
             !(0, typeUtils_1.isOptionalType)(type) &&
             !AnalyzerNodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
@@ -13356,7 +13393,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) {
@@ -13405,7 +13442,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 */);
     }
@@ -13467,7 +13504,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 */);
     }
@@ -13500,7 +13537,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) {
@@ -13529,7 +13566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let symbolType = getAliasedSymbolTypeForName(node, aliasNode.value);
         if (!symbolType) {
             const parentNode = node.parent;
-            (0, debug_1.assert)(parentNode && parentNode.nodeType === 22 /* ParseNodeType.ImportFrom */);
+            (0, debug_1.assert)(parentNode && parentNode.nodeType === 25 /* ParseNodeType.ImportFrom */);
             (0, debug_1.assert)(!parentNode.isWildcardImport);
             const importInfo = AnalyzerNodeInfo.getImportInfo(parentNode.module);
             if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib) {
@@ -13566,7 +13603,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) {
@@ -13664,9 +13701,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 */);
         }
     }
@@ -13721,7 +13756,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!resolvedAliasInfo.declaration) {
             return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
         }
-        if (node.nodeType === 23 /* ParseNodeType.ImportFromAs */) {
+        if (node.nodeType === 26 /* ParseNodeType.ImportFromAs */) {
             if (resolvedAliasInfo.isPrivate) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.LocMessage.privateUsedOutsideOfModule().format({
                     name: node.name.value,
@@ -13751,7 +13786,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // is technically not part of an expression. We'll handle these here so
         // callers don't need to include special-case logic.
         if (node.nodeType === 38 /* ParseNodeType.Name */ && node.parent) {
-            if (node.parent.nodeType === 28 /* ParseNodeType.Function */ && node.parent.name === node) {
+            if (node.parent.nodeType === 31 /* ParseNodeType.Function */ && node.parent.name === node) {
                 getTypeOfFunction(node.parent);
                 return;
             }
@@ -13759,11 +13794,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 getTypeOfClass(node.parent);
                 return;
             }
-            if (node.parent.nodeType === 23 /* ParseNodeType.ImportFromAs */) {
+            if (node.parent.nodeType === 26 /* ParseNodeType.ImportFromAs */) {
                 evaluateTypesForImportFromAs(node.parent);
                 return;
             }
-            if (node.parent.nodeType === 21 /* ParseNodeType.ImportAs */) {
+            if (node.parent.nodeType === 24 /* ParseNodeType.ImportAs */) {
                 evaluateTypesForImportAs(node.parent);
                 return;
             }
@@ -13771,7 +13806,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 getTypeOfTypeAlias(node.parent);
                 return;
             }
-            if (node.parent.nodeType === 29 /* ParseNodeType.Global */ || node.parent.nodeType === 39 /* ParseNodeType.Nonlocal */) {
+            if (node.parent.nodeType === 32 /* ParseNodeType.Global */ || node.parent.nodeType === 39 /* ParseNodeType.Nonlocal */) {
                 // For global and nonlocal statements, allow forward references so
                 // we don't use code flow during symbol lookups.
                 getTypeOfExpression(node, 4 /* EvaluatorFlags.AllowForwardReferences */);
@@ -13807,7 +13842,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 evaluateTypesForTypeAnnotationNode(annotationParent);
                 return;
             }
-            if (annotationParent.nodeType === 28 /* ParseNodeType.Function */ &&
+            if (annotationParent.nodeType === 31 /* ParseNodeType.Function */ &&
                 annotationNode === annotationParent.returnTypeAnnotation) {
                 getTypeOfAnnotation(annotationNode, {
                     associateTypeVarsWithScope: true,
@@ -13843,7 +13878,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (argumentNode && argumentNode !== nodeToEvaluate) {
                 (0, debug_1.assert)(argumentNode.parent !== undefined);
                 if (argumentNode.parent.nodeType === 9 /* ParseNodeType.Call */ ||
-                    argumentNode.parent.nodeType === 24 /* ParseNodeType.Index */) {
+                    argumentNode.parent.nodeType === 27 /* ParseNodeType.Index */) {
                     nodeToEvaluate = argumentNode.parent;
                     continue;
                 }
@@ -13875,7 +13910,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         continue;
                     }
                     // Handle the special case where the LHS is a call to a lambda.
-                    if (parent.nodeType === 9 /* ParseNodeType.Call */ && nodeToEvaluate.nodeType === 30 /* ParseNodeType.Lambda */) {
+                    if (parent.nodeType === 9 /* ParseNodeType.Call */ && nodeToEvaluate.nodeType === 33 /* ParseNodeType.Lambda */) {
                         nodeToEvaluate = parent;
                         continue;
                     }
@@ -13883,7 +13918,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     break;
                 }
             }
-            else if (parent.nodeType === 24 /* ParseNodeType.Index */) {
+            else if (parent.nodeType === 27 /* ParseNodeType.Index */) {
                 // The base expression of an index expression is not contextual.
                 if (nodeToEvaluate === parent.baseExpression) {
                     flags = 2 /* EvaluatorFlags.IndexBaseDefaults */;
@@ -13903,17 +13938,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // stop. However, there are a few special "pass through"
                 // node types that we can skip over to get to a known
                 // expression node.
-                if (parent.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */ ||
-                    parent.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */ ||
-                    parent.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ ||
-                    parent.nodeType === 34 /* ParseNodeType.ListComprehensionIf */) {
+                if (parent.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */ ||
+                    parent.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */ ||
+                    parent.nodeType === 12 /* ParseNodeType.ComprehensionFor */ ||
+                    parent.nodeType === 13 /* ParseNodeType.ComprehensionIf */) {
                     (0, debug_1.assert)(parent.parent !== undefined && (0, parseNodes_1.isExpressionNode)(parent.parent));
                     parent = parent.parent;
                 }
                 else if (parent.nodeType === 41 /* ParseNodeType.Parameter */) {
                     (0, debug_1.assert)(parent.parent !== undefined);
                     // Parameters are contextual for lambdas.
-                    if (parent.parent.nodeType === 30 /* ParseNodeType.Lambda */) {
+                    if (parent.parent.nodeType === 33 /* ParseNodeType.Lambda */) {
                         parent = parent.parent;
                     }
                     else {
@@ -13938,7 +13973,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const parent = nodeToEvaluate.parent;
         (0, debug_1.assert)(parent !== undefined);
         switch (parent.nodeType) {
-            case 14 /* ParseNodeType.Del */: {
+            case 17 /* ParseNodeType.Del */: {
                 verifyDeleteExpression(nodeToEvaluate);
                 return;
             }
@@ -13957,11 +13992,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 getTypeOfTypeAlias(parent);
                 return;
             }
-            case 13 /* ParseNodeType.Decorator */: {
+            case 16 /* ParseNodeType.Decorator */: {
                 if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* ParseNodeType.Class */) {
                     getTypeOfClass(parent.parent);
                 }
-                else if (((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 28 /* ParseNodeType.Function */) {
+                else if (((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 31 /* ParseNodeType.Function */) {
                     getTypeOfFunction(parent.parent);
                 }
                 return;
@@ -14023,11 +14058,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // be inferred, whereas the latter sometimes have type annotations
         // but cannot be inferred.
         const parent = node.parent;
-        if (parent.nodeType === 30 /* ParseNodeType.Lambda */) {
+        if (parent.nodeType === 33 /* ParseNodeType.Lambda */) {
             evaluateTypesForExpressionInContext(parent);
             return;
         }
-        (0, debug_1.assert)(parent.nodeType === 28 /* ParseNodeType.Function */);
+        (0, debug_1.assert)(parent.nodeType === 31 /* ParseNodeType.Function */);
         const functionNode = parent;
         const paramIndex = functionNode.parameters.findIndex((param) => param === node);
         const typeAnnotation = ParseTreeUtils.getTypeAnnotationForParameter(functionNode, paramIndex);
@@ -14063,7 +14098,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // be evaluated to provide sufficient context for the type. Evaluated types
     // are written back to the type cache for later retrieval.
     function evaluateTypesForStatement(node) {
-        initializedBasicTypes(node);
+        initializePrefetchedTypes(node);
         let curNode = node;
         while (curNode) {
             switch (curNode.nodeType) {
@@ -14086,7 +14121,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return;
                 }
                 case 4 /* ParseNodeType.AssignmentExpression */: {
-                    getTypeOfExpression(curNode);
+                    evaluateTypesForExpressionInContext(curNode);
                     return;
                 }
                 case 5 /* ParseNodeType.AugmentedAssignment */: {
@@ -14101,19 +14136,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     evaluateTypeOfParameter(curNode);
                     return;
                 }
-                case 30 /* ParseNodeType.Lambda */: {
+                case 33 /* ParseNodeType.Lambda */: {
                     evaluateTypesForExpressionInContext(curNode);
                     return;
                 }
-                case 28 /* ParseNodeType.Function */: {
+                case 31 /* ParseNodeType.Function */: {
                     getTypeOfFunction(curNode);
                     return;
                 }
-                case 26 /* ParseNodeType.For */: {
+                case 29 /* ParseNodeType.For */: {
                     evaluateTypesForForStatement(curNode);
                     return;
                 }
-                case 25 /* ParseNodeType.Except */: {
+                case 28 /* ParseNodeType.Except */: {
                     evaluateTypesForExceptStatement(curNode);
                     return;
                 }
@@ -14121,17 +14156,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     evaluateTypesForWithStatement(curNode);
                     return;
                 }
-                case 33 /* ParseNodeType.ListComprehensionFor */: {
-                    const listComprehension = curNode.parent;
-                    (0, debug_1.assert)(listComprehension.nodeType === 32 /* ParseNodeType.ListComprehension */);
-                    if (curNode === listComprehension.expression) {
-                        evaluateTypesForExpressionInContext(listComprehension);
+                case 12 /* ParseNodeType.ComprehensionFor */: {
+                    const comprehension = curNode.parent;
+                    (0, debug_1.assert)(comprehension.nodeType === 11 /* ParseNodeType.Comprehension */);
+                    if (curNode === comprehension.expression) {
+                        evaluateTypesForExpressionInContext(comprehension);
                     }
                     else {
                         // Evaluate the individual iterations starting with the first
                         // up to the curNode.
-                        for (const forIfNode of listComprehension.forIfNodes) {
-                            evaluateListComprehensionForIf(forIfNode);
+                        for (const forIfNode of comprehension.forIfNodes) {
+                            evaluateComprehensionForIf(forIfNode);
                             if (forIfNode === curNode) {
                                 break;
                             }
@@ -14139,15 +14174,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     return;
                 }
-                case 21 /* ParseNodeType.ImportAs */: {
+                case 24 /* ParseNodeType.ImportAs */: {
                     evaluateTypesForImportAs(curNode);
                     return;
                 }
-                case 23 /* ParseNodeType.ImportFromAs */: {
+                case 26 /* ParseNodeType.ImportFromAs */: {
                     evaluateTypesForImportFromAs(curNode);
                     return;
                 }
-                case 22 /* ParseNodeType.ImportFrom */: {
+                case 25 /* ParseNodeType.ImportFrom */: {
                     evaluateTypesForImportFrom(curNode);
                     return;
                 }
@@ -14371,8 +14406,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return { type: types_1.UnknownType.create() };
                     }
                 }
-                if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
-                    let typeType = createSpecialType(typeClassType, typeArgs, 1, 
+                if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
+                    let typeType = createSpecialType(typeClass, typeArgs, 1, 
                     /* allowParamSpec */ undefined, 
                     /* isSpecialForm */ false);
                     if ((0, types_1.isInstantiableClass)(typeType)) {
@@ -14503,7 +14538,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;
@@ -14531,12 +14566,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 {
@@ -14710,7 +14744,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Functions and list comprehensions don't allow access to implicitly
         // aliased symbols in outer scopes if they haven't yet been assigned
         // within the local scope.
-        let scopeTypeHonorsCodeFlow = scopeType !== 2 /* ScopeType.Function */ && scopeType !== 1 /* ScopeType.ListComprehension */;
+        let scopeTypeHonorsCodeFlow = scopeType !== 2 /* ScopeType.Function */ && scopeType !== 1 /* ScopeType.Comprehension */;
         // TypeParameter scopes don't honor code flow, but if the symbol is resolved
         // using the proxy scope for the TypeParameter scope, we should use code flow.
         if (scopeType === 0 /* ScopeType.TypeParameter */ && symbolWithScope && symbolWithScope.scope === scope) {
@@ -14914,7 +14948,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getAliasFromImport(node) {
         if (node.parent &&
-            node.parent.nodeType === 23 /* ParseNodeType.ImportFromAs */ &&
+            node.parent.nodeType === 26 /* ParseNodeType.ImportFromAs */ &&
             node.parent.alias &&
             node === node.parent.name) {
             return node.parent.alias;
@@ -15145,7 +15179,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // has a function-level annotation comment that provides
                 // this parameter's annotation type.
                 if (!typeAnnotationNode) {
-                    if (((_a = declaration.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 28 /* ParseNodeType.Function */) {
+                    if (((_a = declaration.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 31 /* ParseNodeType.Function */) {
                         const functionNode = declaration.node.parent;
                         if (functionNode.functionAnnotationComment &&
                             !functionNode.functionAnnotationComment.isParamListEllipsis) {
@@ -15313,7 +15347,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Set the variance to "auto" for class-scoped TypeVars.
                 typeVar.details.declaredVariance = 0 /* Variance.Auto */;
             }
-            else if (scopeNode.nodeType === 28 /* ParseNodeType.Function */) {
+            else if (scopeNode.nodeType === 31 /* ParseNodeType.Function */) {
                 scopeType = 1 /* TypeVarScopeType.Function */;
             }
             else {
@@ -15899,7 +15933,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)
@@ -16158,7 +16192,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfMember(member) {
         if ((0, types_1.isInstantiableClass)(member.classType)) {
             return (0, typeUtils_1.partiallySpecializeType)(getEffectiveTypeOfSymbol(member.symbol), member.classType, 
-            /* selfClass */ undefined, typeClassType !== null && typeClassType !== void 0 ? typeClassType : types_1.UnknownType.create());
+            /* selfClass */ undefined, typeClass !== null && typeClass !== void 0 ? typeClass : types_1.UnknownType.create());
         }
         return types_1.UnknownType.create();
     }
@@ -16170,20 +16204,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);
                     }
                 }
@@ -16235,22 +16267,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (types_1.ClassType.isBuiltIn(destType, 'Mapping')) {
                 const mappingValueType = (0, typedDicts_1.getTypedDictMappingEquivalent)(evaluatorInterface, srcType);
                 if (mappingValueType &&
-                    mappingType &&
-                    (0, types_1.isInstantiableClass)(mappingType) &&
-                    strClassType &&
-                    (0, types_1.isInstantiableClass)(strClassType)) {
-                    srcType = types_1.ClassType.cloneForSpecialization(mappingType, [types_1.ClassType.cloneAsInstance(strClassType), mappingValueType], 
+                    mappingClass &&
+                    (0, types_1.isInstantiableClass)(mappingClass) &&
+                    strClass &&
+                    (0, types_1.isInstantiableClass)(strClass)) {
+                    srcType = types_1.ClassType.cloneForSpecialization(mappingClass, [types_1.ClassType.cloneAsInstance(strClass), mappingValueType], 
                     /* isTypeArgumentExplicit */ true);
                 }
             }
             else if (types_1.ClassType.isBuiltIn(destType, ['dict', 'MutableMapping'])) {
                 const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, srcType, recursionCount);
                 if (dictValueType &&
-                    dictClassType &&
-                    (0, types_1.isInstantiableClass)(dictClassType) &&
-                    strClassType &&
-                    (0, types_1.isInstantiableClass)(strClassType)) {
-                    srcType = types_1.ClassType.cloneForSpecialization(dictClassType, [types_1.ClassType.cloneAsInstance(strClassType), dictValueType], 
+                    dictClass &&
+                    (0, types_1.isInstantiableClass)(dictClass) &&
+                    strClass &&
+                    (0, types_1.isInstantiableClass)(strClass)) {
+                    srcType = types_1.ClassType.cloneForSpecialization(dictClass, [types_1.ClassType.cloneAsInstance(strClass), dictValueType], 
                     /* isTypeArgumentExplicit */ true);
                 }
             }
@@ -16477,7 +16509,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If the only removed arg from the dest type args is itself a variadic,
                 // don't bother adjusting it.
                 const skipAdjustment = destArgsToCapture === 1 && (0, types_1.isVariadicTypeVar)(destTypeArgs[srcVariadicIndex].type);
-                if (!skipAdjustment && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                if (!skipAdjustment && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
                     const removedArgs = destTypeArgs.splice(srcVariadicIndex, destArgsToCapture);
                     // Package up the remaining type arguments into a tuple object.
                     const variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
@@ -16501,7 +16533,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If the dest contains a variadic element, determine which source
                 // args map to this element and package them up into an unpacked tuple.
                 if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedOrVariadicIndex].type)) {
-                    if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                    if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
                         const removedArgs = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture);
                         let variadicTuple;
                         // If we're left with a single unpacked variadic type var, there's no
@@ -16966,20 +16998,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // rather than dest. If the type variable is not in the scope of the
                 // provided TypeVarContext, simply verify that the concrete types are
                 // compatible.
-                if (!srcTypeVarContext || !srcTypeVarContext.hasSolveForScope((0, typeUtils_1.getTypeVarScopeId)(srcType))) {
+                if ((flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */) === 0 &&
+                    (!srcTypeVarContext || !srcTypeVarContext.hasSolveForScope((0, typeUtils_1.getTypeVarScopeId)(srcType)))) {
                     return assignType(makeTopLevelTypeVarsConcrete(destType), makeTopLevelTypeVarsConcrete(srcType), diag, 
                     /* destTypeVarContext */ undefined, 
                     /* srcTypeVarContext */ undefined, originalFlags, recursionCount);
                 }
                 else {
-                    if ((0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, srcType, destType, diag, srcTypeVarContext, originalFlags, recursionCount)) {
+                    if ((0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, srcType, destType, diag, srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext(), originalFlags, recursionCount)) {
                         return true;
                     }
                     // If the dest type is a union, only one of the subtypes needs to match.
                     let isAssignable = false;
                     if ((0, types_1.isUnion)(destType)) {
                         (0, typeUtils_1.doForEachSubtype)(destType, (destSubtype) => {
-                            if ((0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, srcType, destSubtype, diag, srcTypeVarContext, originalFlags, recursionCount)) {
+                            if ((0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, srcType, destSubtype, diag, srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext(), originalFlags, recursionCount)) {
                                 isAssignable = true;
                             }
                         });
@@ -16996,7 +17029,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;
                 }
@@ -17209,10 +17242,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
-                    strClassType &&
-                    (0, types_1.isInstantiableClass)(strClassType) &&
+                    strClass &&
+                    (0, types_1.isInstantiableClass)(strClass) &&
                     (flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0) {
-                    concreteSrcType = types_1.ClassType.cloneAsInstance(strClassType);
+                    concreteSrcType = types_1.ClassType.cloneAsInstance(strClass);
                 }
                 if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ true)) {
@@ -17227,8 +17260,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return assignType(destCallbackType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
                 // All functions are considered instances of "builtins.function".
-                if (functionObj && (0, types_1.isClassInstance)(functionObj)) {
-                    return assignType(destType, functionObj, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                if (functionClass) {
+                    return assignType(destType, (0, typeUtils_1.convertToInstance)(functionClass), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isModule)(concreteSrcType)) {
@@ -17278,7 +17311,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.
@@ -17382,8 +17415,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Are we trying to assign None to a protocol?
         if ((0, typeUtils_1.isNoneInstance)(srcType) && (0, types_1.isClassInstance)(destType) && types_1.ClassType.isProtocolClass(destType)) {
-            if (noneClassType && (0, types_1.isInstantiableClass)(noneClassType)) {
-                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneClassType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+            if (noneTypeClass && (0, types_1.isInstantiableClass)(noneTypeClass)) {
+                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneTypeClass), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
             }
         }
         if ((0, typeUtils_1.isNoneInstance)(destType)) {
@@ -17810,8 +17843,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 for (const field of types_1.ClassType.getSymbolTable(mroClass)) {
                     if (field[0] !== '__call__' && !field[1].isIgnoredForProtocolMatch()) {
                         let fieldIsPartOfFunction = false;
-                        if (functionObj && (0, types_1.isClass)(functionObj)) {
-                            if (types_1.ClassType.getSymbolTable(functionObj).has(field[0])) {
+                        if (functionClass && (0, types_1.isClass)(functionClass)) {
+                            if (types_1.ClassType.getSymbolTable(functionClass).has(field[0])) {
                                 fieldIsPartOfFunction = true;
                             }
                         }
@@ -17822,13 +17855,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
@@ -17960,17 +17987,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);
@@ -18058,7 +18091,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({
@@ -18094,7 +18127,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;
@@ -18161,7 +18194,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)) {
@@ -18176,9 +18209,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({
@@ -18293,9 +18326,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,
@@ -18305,8 +18338,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;
             }
@@ -18321,9 +18353,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;
@@ -18360,13 +18394,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;
@@ -18376,16 +18408,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;
                         }
@@ -18417,9 +18451,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // type at runtime.
                     if ((0, types_1.isClassInstance)(srcReturnType) &&
                         types_1.ClassType.isBuiltIn(srcReturnType, ['TypeGuard', 'TypeIs']) &&
-                        boolClassType &&
-                        (0, types_1.isInstantiableClass)(boolClassType)) {
-                        if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClassType), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                        boolClass &&
+                        (0, types_1.isInstantiableClass)(boolClass)) {
+                        if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                             isReturnTypeCompatible = true;
                         }
                     }
@@ -18467,7 +18501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         replacedTypeArg = true;
                         return expectedTypeArgType;
                     }
-                    else if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
+                    if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
                         // Recursively replace Any in the type argument.
                         const recursiveReplacement = replaceTypeArgsWithAny(node, expectedTypeArgType, typeArg, recursionCount);
                         if (recursiveReplacement) {
@@ -18506,8 +18540,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) {
-        const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedType, (assignedSubtype) => {
+    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.
+        // 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,8 +18584,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return declaredSubtype;
                     }
                     // If the declared type doesn't contain any `Any` but the assigned
-                    // type does, stick with the declared type.
-                    if ((0, typeUtils_1.containsAnyRecursive)(assignedSubtype) && !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
+                    // type does, stick with the declared type. We don't include unknowns
+                    // in the assigned subtype check here so unknowns are preserved so
+                    // reportUnknownVariableType assignment diagnostics are reported.
+                    // TODO - this is an inconsistency because Any and Unknown should
+                    // always be treated the same for purposes of type narrowing. This
+                    // should be revisited once the narrowing-on-assignment behavior
+                    // is properly specified in the typing spec.
+                    if ((0, typeUtils_1.containsAnyRecursive)(assignedSubtype, /* includeUnknown */ false) &&
+                        !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
                         return declaredSubtype;
                     }
                     return assignedSubtype;
@@ -18562,12 +18612,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.
@@ -18697,8 +18747,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)) {
@@ -19158,7 +19207,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,
                             }));
@@ -19215,21 +19264,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 56 /* ParseNodeType.Unpack */:
             case 52 /* ParseNodeType.Tuple */:
             case 9 /* ParseNodeType.Call */:
-            case 32 /* ParseNodeType.ListComprehension */:
+            case 11 /* ParseNodeType.Comprehension */:
             case 46 /* ParseNodeType.Slice */:
             case 60 /* ParseNodeType.Yield */:
             case 61 /* ParseNodeType.YieldFrom */:
-            case 30 /* ParseNodeType.Lambda */:
+            case 33 /* ParseNodeType.Lambda */:
             case 40 /* ParseNodeType.Number */:
-            case 15 /* ParseNodeType.Dictionary */:
-            case 31 /* ParseNodeType.List */:
+            case 18 /* ParseNodeType.Dictionary */:
+            case 34 /* ParseNodeType.List */:
             case 45 /* ParseNodeType.Set */:
                 return false;
             case 7 /* ParseNodeType.BinaryOperation */:
                 return (node.operator === 6 /* OperatorType.BitwiseOr */ &&
                     isLegalTypeAliasExpressionForm(node.leftExpression) &&
                     isLegalTypeAliasExpressionForm(node.rightExpression));
-            case 24 /* ParseNodeType.Index */:
+            case 27 /* ParseNodeType.Index */:
                 return isLegalTypeAliasExpressionForm(node.baseExpression);
             case 35 /* ParseNodeType.MemberAccess */:
                 return isLegalTypeAliasExpressionForm(node.leftExpression);