@zzzen/pyright-internal 1.2.0-dev.20221225 → 1.2.0-dev.20230108

package/dist/analyzer/typeEvaluator.js

@@ -67,7 +67,7 @@ const staticExpressions_1 = require("./staticExpressions");
 const symbol_1 = require("./symbol");
 const symbolNameUtils_1 = require("./symbolNameUtils");
 const symbolUtils_1 = require("./symbolUtils");
-const typeCache_1 = require("./typeCache");
+const typeCacheUtils_1 = require("./typeCacheUtils");
 const typedDicts_1 = require("./typedDicts");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const TypePrinter = __importStar(require("./typePrinter"));
@@ -227,9 +227,8 @@ const maxLiteralMathSubtypeCount = 64;
 exports.maxCodeComplexity = 768;
 function createTypeEvaluator(importLookup, evaluatorOptions) {
     const symbolResolutionStack = [];
-    const typeCacheFlags = new Map();
     const asymmetricDescriptorAssignmentCache = new Set();
-    const speculativeTypeTracker = new typeCache_1.SpeculativeTypeTracker();
+    const speculativeTypeTracker = new typeCacheUtils_1.SpeculativeTypeTracker();
     const suppressedNodeStack = [];
     let functionRecursionMap = new Set();
     let codeFlowAnalyzerCache = new Map();
@@ -250,7 +249,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let strClassType;
     let dictClassType;
     let typedDictClassType;
-    let incompleteTypeCache;
     let printExpressionSpaceCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
@@ -284,33 +282,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         effectiveTypeCache = new Map();
         expectedTypeCache = new Map();
     }
-    function isTypeCached(node) {
-        let cachedType;
+    function readTypeCacheEntry(node) {
+        // Should we use a temporary cache associated with a contextual
+        // analysis of a function, contextualized based on call-site argument types?
         if (returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)) {
-            cachedType = returnTypeInferenceTypeCache.get(node.id);
+            return returnTypeInferenceTypeCache.get(node.id);
         }
         else {
-            cachedType = typeCache.get(node.id);
+            return typeCache.get(node.id);
         }
-        return cachedType !== undefined;
+    }
+    function isTypeCached(node) {
+        const cachedEntry = readTypeCacheEntry(node);
+        return cachedEntry !== undefined && !cachedEntry.typeResult.isIncomplete;
     }
     function readTypeCache(node, flags) {
         var _a, _b;
-        let cachedType;
-        // Should we use a temporary cache associated with a contextual
-        // analysis of a function, contextualized based on call-site argument types?
-        if (returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)) {
-            cachedType = returnTypeInferenceTypeCache.get(node.id);
-        }
-        else {
-            cachedType = typeCache.get(node.id);
-        }
-        if (cachedType === undefined) {
+        const cacheEntry = readTypeCacheEntry(node);
+        if (!cacheEntry || cacheEntry.typeResult.isIncomplete) {
             return undefined;
         }
         if (evaluatorOptions.verifyTypeCacheEvaluatorFlags || verifyTypeCacheEvaluatorFlags) {
             if (flags !== undefined) {
-                const expectedFlags = typeCacheFlags.get(node.id);
+                const expectedFlags = cacheEntry.flags;
                 if (expectedFlags !== undefined && flags !== expectedFlags) {
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                     const position = (0, positionUtils_1.convertOffsetToPosition)(node.start, fileInfo.lines);
@@ -327,34 +321,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        (0, debug_1.assert)(!(0, typeCache_1.isIncompleteType)(cachedType));
-        return cachedType;
+        return cacheEntry.typeResult.type;
     }
-    function writeTypeCache(node, type, flags, isIncomplete, expectedType, allowSpeculativeCaching = false) {
-        if (isIncomplete) {
-            if (incompleteTypeCache) {
-                incompleteTypeCache.set(node.id, type);
-            }
-            return;
-        }
+    function writeTypeCache(node, typeResult, flags, expectedType, allowSpeculativeCaching = false) {
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
         const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)
             ? returnTypeInferenceTypeCache
             : typeCache;
-        typeCacheToUse.set(node.id, type);
-        if (evaluatorOptions.verifyTypeCacheEvaluatorFlags || verifyTypeCacheEvaluatorFlags) {
-            if (typeCacheToUse === typeCache && flags !== undefined) {
-                typeCacheFlags.set(node.id, flags);
-            }
-        }
+        typeCacheToUse.set(node.id, { typeResult, flags });
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
         // this speculative context.
         if (speculativeTypeTracker.isSpeculative(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
-            if (allowSpeculativeCaching) {
-                speculativeTypeTracker.addSpeculativeType(node, type, expectedType);
+            if (allowSpeculativeCaching && !typeResult.isIncomplete) {
+                speculativeTypeTracker.addSpeculativeType(node, typeResult, expectedType);
             }
         }
     }
@@ -365,7 +347,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeCacheToUse.delete(node.id);
     }
     function setTypeForNode(node, type = types_1.UnknownType.create(), flags = 0 /* None */) {
-        writeTypeCache(node, type, flags, /* isIncomplete */ false);
+        writeTypeCache(node, { type }, flags);
     }
     function setAsymmetricDescriptorAssignment(node) {
         if (speculativeTypeTracker.isSpeculative(/* node */ undefined)) {
@@ -447,6 +429,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
     }
+    function getTypeResult(node) {
+        return evaluateTypeForSubnode(node, () => {
+            evaluateTypesForExpressionInContext(node);
+        });
+    }
     // Reads the type of the node from the cache.
     function getCachedType(node) {
         return readTypeCache(node, 0 /* None */);
@@ -508,21 +495,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfExpression(node, flags = 0 /* None */, expectedType) {
         var _a;
         // Is this type already cached?
-        const cachedType = readTypeCache(node, flags);
-        if (cachedType) {
+        const cacheEntry = readTypeCacheEntry(node);
+        if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
             if (printExpressionTypes) {
-                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cachedType)}`);
+                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
             }
-            return { type: cachedType };
+            return cacheEntry.typeResult;
         }
         else {
             // Is it cached in the speculative type cache?
-            const speculativeCachedType = speculativeTypeTracker.getSpeculativeType(node, expectedType);
-            if (speculativeCachedType) {
+            const cachedTypeResult = speculativeTypeTracker.getSpeculativeType(node, expectedType);
+            if (cachedTypeResult) {
                 if (printExpressionTypes) {
-                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(speculativeCachedType)}`);
+                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cachedTypeResult.type)}`);
                 }
-                return { type: speculativeCachedType };
+                return cachedTypeResult;
             }
         }
         if (printExpressionTypes) {
@@ -707,8 +694,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult.type.details.illegalRecursionDetected = true;
             }
         }
-        writeTypeCache(node, typeResult.type, flags, !!typeResult.isIncomplete, expectedType, 
-        /* allowSpeculativeCaching */ true);
+        writeTypeCache(node, typeResult, flags, expectedType, /* allowSpeculativeCaching */ true);
         if (expectedType && !(0, types_1.isAnyOrUnknown)(expectedType) && !(0, types_1.isNever)(expectedType)) {
             expectedTypeCache.set(node.id, expectedType);
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
@@ -2099,7 +2085,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!isTypeIncomplete) {
             reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
         }
-        writeTypeCache(nameNode, destType, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* DoNotSpecialize */);
@@ -2143,8 +2129,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (setTypeResult.isAsymmetricDescriptor) {
             setAsymmetricDescriptorAssignment(target);
         }
-        writeTypeCache(target.memberName, type, 0 /* None */, isTypeIncomplete);
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target.memberName, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
+        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
         const memberName = node.memberName.value;
@@ -2319,7 +2305,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const targetType = typeList.length === 0 ? types_1.UnknownType.create() : (0, types_1.combineTypes)(typeList);
             assignTypeToExpression(expr, targetType, isTypeIncomplete, srcExpr, /* ignoreEmptyContainers */ true);
         });
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     // Replaces all of the top-level TypeVars (as opposed to TypeVars
     // used as type arguments in other types) with their concrete form.
@@ -2546,7 +2532,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     setErrorNode: srcExpr,
                     setExpectedTypeDiag: expectedTypeDiagAddendum,
                 }, 0 /* None */);
-                writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+                writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
                 break;
             }
             case 31 /* List */:
@@ -2669,14 +2655,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 35 /* MemberAccess */: {
                 const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
                 const memberType = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
-                writeTypeCache(node.memberName, memberType.type, 0 /* None */, /* isIncomplete */ false);
-                writeTypeCache(node, memberType.type, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node.memberName, { type: memberType.type }, 0 /* None */);
+                writeTypeCache(node, { type: memberType.type }, 0 /* None */);
                 break;
             }
             case 24 /* Index */: {
                 const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* DoNotSpecialize */);
                 getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
-                writeTypeCache(node, types_1.UnboundType.create(), 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* None */);
                 break;
             }
             case 52 /* Tuple */: {
@@ -2758,7 +2744,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getTypeOfName(node, flags) {
-        var _a, _b;
+        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -2769,7 +2755,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
         if (typeParamSymbol) {
             symbol = typeParamSymbol;
-            type = (_a = getDeclaredTypeOfSymbol(typeParamSymbol)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+            (0, debug_1.assert)(symbol.getDeclarations().length === 1);
+            const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            (0, debug_1.assert)((decl === null || decl === void 0 ? void 0 : decl.type) === 3 /* TypeParameter */);
+            type = getTypeOfTypeParameter(decl.node);
             setSymbolAccessed(fileInfo, symbol, node);
         }
         else {
@@ -2910,7 +2899,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type.details.name === name) {
             // Handle the special case of a PEP 604 union. These can appear within
             // an implied type alias where we are not expecting a type.
-            const isPep604Union = ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 7 /* BinaryOperation */ &&
+            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
                 node.parent.operator === 6 /* BitwiseOr */;
             if (!isPep604Union) {
                 // A TypeVar in contexts where we're not expecting a type is
@@ -3026,7 +3015,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (memberName === 'args' || memberName === 'kwargs') {
                                 const outerFunctionScope = ParseTreeUtils.getEnclosingClassOrFunction(enclosingScope);
                                 if ((outerFunctionScope === null || outerFunctionScope === void 0 ? void 0 : outerFunctionScope.nodeType) === 28 /* Function */) {
-                                    enclosingScope = outerFunctionScope;
+                                    if (scopedTypeVarInfo.isRescoped) {
+                                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet
+                                            .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecScopedToReturnType().format({
+                                            name: type.details.name,
+                                        }), node);
+                                    }
+                                    else {
+                                        enclosingScope = outerFunctionScope;
+                                    }
                                 }
                                 else if (!scopedTypeVarInfo.type.scopeId) {
                                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotUsedByOuterScope().format({
@@ -3038,7 +3035,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (enclosingScope) {
                             // If the enclosing scope is using type parameter syntax, traditional
                             // type variables can't be used in this context.
-                            if (enclosingScope.typeParameters) {
+                            if (enclosingScope.typeParameters &&
+                                !enclosingScope.typeParameters.parameters.some((param) => param.name.value === type.details.name)) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeParameterNotDeclared().format({
                                     name: type.details.name,
                                     container: enclosingScope.name.value,
@@ -3060,9 +3058,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if ((flags & 4096 /* DisallowTypeVarsWithoutScopeId */) !== 0) {
                 if ((type.scopeId === undefined || scopedTypeVarInfo.foundInterveningClass) &&
                     !type.details.isSynthesized) {
-                    const message = (0, types_1.isParamSpec)(type)
-                        ? localize_1.Localizer.Diagnostic.paramSpecNotUsedByOuterScope()
-                        : localize_1.Localizer.Diagnostic.typeVarNotUsedByOuterScope();
+                    let message;
+                    if (scopedTypeVarInfo.isRescoped) {
+                        message = (0, types_1.isParamSpec)(type)
+                            ? localize_1.Localizer.Diagnostic.paramSpecScopedToReturnType()
+                            : localize_1.Localizer.Diagnostic.typeVarScopedToReturnType();
+                    }
+                    else {
+                        message = (0, types_1.isParamSpec)(type)
+                            ? localize_1.Localizer.Diagnostic.paramSpecNotUsedByOuterScope()
+                            : localize_1.Localizer.Diagnostic.typeVarNotUsedByOuterScope();
+                    }
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name: type.details.name }), node);
                 }
             }
@@ -3078,43 +3084,51 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // type arguments. If so, it fills in these type arguments with Unknown
     // and optionally reports an error.
     function reportMissingTypeArguments(node, type, flags) {
-        if ((flags & 2 /* DoNotSpecialize */) === 0) {
-            if ((0, types_1.isInstantiableClass)(type)) {
-                if ((flags & 64 /* ExpectingType */) !== 0) {
-                    if ((0, typeUtils_1.requiresTypeArguments)(type) && !type.typeArguments) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
-                            name: type.aliasName || type.details.name,
-                        }), node);
-                    }
-                }
-                if (!type.typeArguments) {
-                    type = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node);
+        if ((flags & 2 /* DoNotSpecialize */) !== 0) {
+            return type;
+        }
+        // Is this a generic class that needs to be specialized?
+        if ((0, types_1.isInstantiableClass)(type)) {
+            if ((flags & 64 /* ExpectingType */) !== 0) {
+                if ((0, typeUtils_1.requiresTypeArguments)(type) && !type.typeArguments) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
+                        name: type.aliasName || type.details.name,
+                    }), node);
                 }
             }
-            if ((flags & 64 /* ExpectingType */) !== 0 &&
-                type.typeAliasInfo &&
-                type.typeAliasInfo.typeParameters &&
-                type.typeAliasInfo.typeParameters.length > 0 &&
-                !type.typeAliasInfo.typeArguments) {
-                let reportMissingTypeArguments = false;
-                const defaultTypeArgs = [];
-                type.typeAliasInfo.typeParameters.forEach((param) => {
-                    if (param.details.defaultType) {
-                        defaultTypeArgs.push(param.details.defaultType);
-                    }
-                    else {
-                        defaultTypeArgs.push(types_1.UnknownType.create());
-                        reportMissingTypeArguments = true;
-                    }
-                });
-                const typeVarContext = (0, typeUtils_1.buildTypeVarContext)(type.typeAliasInfo.typeParameters, defaultTypeArgs, type.typeAliasInfo.typeVarScopeId);
-                if (reportMissingTypeArguments) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForAlias().format({
-                        name: type.typeAliasInfo.name,
-                    }), node);
+            if (!type.typeArguments) {
+                type = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node);
+            }
+        }
+        // Is this a generic type alias that needs to be specialized?
+        if ((flags & 64 /* ExpectingType */) !== 0 &&
+            type.typeAliasInfo &&
+            type.typeAliasInfo.typeParameters &&
+            type.typeAliasInfo.typeParameters.length > 0 &&
+            !type.typeAliasInfo.typeArguments) {
+            let reportMissingTypeArguments = false;
+            const defaultTypeArgs = [];
+            const typeVarContext = new typeVarContext_1.TypeVarContext(type.typeAliasInfo.typeVarScopeId);
+            type.typeAliasInfo.typeParameters.forEach((param) => {
+                if (!param.details.defaultType) {
+                    reportMissingTypeArguments = true;
+                }
+                let defaultType;
+                if (param.details.defaultType || param.details.isParamSpec) {
+                    defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
+                }
+                else {
+                    defaultType = types_1.UnknownType.create();
                 }
-                type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, /* unknownIfNotFound */ true), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, defaultTypeArgs);
+                defaultTypeArgs.push(defaultType);
+                typeVarContext.setTypeVarType(param, defaultType);
+            });
+            if (reportMissingTypeArguments) {
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForAlias().format({
+                    name: type.typeAliasInfo.name,
+                }), node);
             }
+            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, defaultTypeArgs);
         }
         return type;
     }
@@ -3148,8 +3162,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return scopeIds;
     }
     // Walks up the parse tree to find a function, class, or type alias
-    // assignment that provides the context for a type variable.
+    // declaration that provides the context for a type variable.
     function findScopedTypeVar(node, type) {
+        var _a;
         let curNode = node;
         let nestedClassCount = 0;
         (0, debug_1.assert)(types_1.TypeBase.isInstantiable(type));
@@ -3171,14 +3186,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (curNode.nodeType === 28 /* Function */) {
                 const functionTypeInfo = getTypeOfFunction(curNode);
                 if (functionTypeInfo) {
-                    typeParametersForScope = [];
-                    functionTypeInfo.functionType.details.parameters.forEach((param) => {
-                        if (param.hasDeclaredType) {
-                            (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersForScope, (0, typeUtils_1.getTypeVarArgumentsRecursive)(param.type));
-                        }
-                    });
-                    if (functionTypeInfo.functionType.details.declaredReturnType) {
-                        (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersForScope, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionTypeInfo.functionType.details.declaredReturnType));
+                    const functionDetails = functionTypeInfo.functionType.details;
+                    typeParametersForScope = functionDetails.typeParameters;
+                    // Was this type parameter "rescoped" to a callable found within the
+                    // return type annotation? If so, it is not available for use within
+                    // the function body.
+                    if ((_a = functionDetails.rescopedTypeParameters) === null || _a === void 0 ? void 0 : _a.some((tp) => tp.details.name === type.details.name)) {
+                        return { type, isRescoped: true, foundInterveningClass: false };
                     }
                 }
                 scopeUsesTypeParameterSyntax = !!curNode.typeParameters;
@@ -3191,7 +3205,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (match === null || match === void 0 ? void 0 : match.scopeId) {
                     // Use the scoped version of the TypeVar rather than the (unscoped) original type.
                     type = types_1.TypeVarType.cloneForScopeId(type, match.scopeId, match.scopeName, match.scopeType);
-                    return { type, foundInterveningClass: nestedClassCount > 1 && !scopeUsesTypeParameterSyntax };
+                    return {
+                        type,
+                        isRescoped: false,
+                        foundInterveningClass: nestedClassCount > 1 && !scopeUsesTypeParameterSyntax,
+                    };
                 }
             }
             curNode = curNode.parent;
@@ -3224,6 +3242,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return {
                         type: types_1.TypeVarType.cloneForScopeId(type, leftType.details.recursiveTypeAliasScopeId, leftType.details.recursiveTypeAliasName, 2 /* TypeAlias */),
+                        isRescoped: false,
                         foundInterveningClass: false,
                     };
                 }
@@ -3231,7 +3250,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             curNode = curNode.parent;
         }
         // Return the original type.
-        return { type, foundInterveningClass: false };
+        return { type, isRescoped: false, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
         const baseTypeFlags = 2 /* DoNotSpecialize */ |
@@ -3253,8 +3272,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'get' }, flags | 2 /* DoNotSpecialize */);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // Before performing code flow analysis, update the cache to prevent recursion.
-            writeTypeCache(node, typeResult.type, flags, /* isIncomplete */ true);
-            writeTypeCache(node.memberName, typeResult.type, flags, /* isIncomplete */ true);
+            writeTypeCache(node, { ...typeResult, isIncomplete: true }, flags);
+            writeTypeCache(node.memberName, { ...typeResult, isIncomplete: true }, flags);
             // If the type is initially unbound, see if there's a parent class that
             // potentially initialized the value.
             let typeAtStart = typeResult.type;
@@ -3294,7 +3313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeResult.isIncomplete = true;
         }
         // Cache the type information in the member name node.
-        writeTypeCache(node.memberName, typeResult.type, flags, !!typeResult.isIncomplete);
+        writeTypeCache(node.memberName, typeResult, flags);
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
@@ -3667,7 +3686,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             // Don't include variables within typed dict classes.
-            if (types_1.ClassType.isTypedDictClass(classType)) {
+            if ((0, types_1.isClass)(memberInfo.classType) && types_1.ClassType.isTypedDictClass(memberInfo.classType)) {
                 const typedDecls = memberInfo.symbol.getTypedDeclarations();
                 if (typedDecls.length > 0 && typedDecls[0].type === 1 /* Variable */) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
@@ -4173,7 +4192,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             if (baseTypeSupportsIndexNarrowing) {
                 // Before performing code flow analysis, update the cache to prevent recursion.
-                writeTypeCache(node, indexTypeResult.type, flags, /* isIncomplete */ false);
+                writeTypeCache(node, indexTypeResult, flags);
                 // See if we can refine the type based on code flow analysis.
                 const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, indexTypeResult.type, 
                 /* startNode */ undefined, {
@@ -4205,12 +4224,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return indexTypeResult;
     }
-    function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, errorNode) {
-        var _a;
+    function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, typeVarScopeId, errorNode) {
         const variadicIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         // Do we need to adjust the type arguments to map to a variadic type
         // param at the end of the list?
         if (variadicIndex >= 0) {
+            const variadicTypeVar = typeParameters[variadicIndex];
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                 if (variadicIndex < typeArgs.length) {
                     const variadicTypeResults = typeArgs.slice(variadicIndex, variadicIndex + 1 + typeArgs.length - typeParameters.length);
@@ -4250,11 +4269,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         ];
                     }
                 }
-                else {
+                else if (!variadicTypeVar.details.defaultType) {
                     // Add an empty tuple that maps to the TypeVarTuple type parameter.
                     typeArgs.push({
                         node: errorNode,
-                        type: (_a = typeParameters[variadicIndex].details.defaultType) !== null && _a !== void 0 ? _a : (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
+                        type: (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
                         /* isTypeArgumentExplicit */ true, 
                         /* isUnpackedTuple */ true)),
                     });
@@ -4291,7 +4310,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const typeParameters = baseType.typeAliasInfo.typeParameters;
-        let typeArgs = adjustTypeArgumentsForVariadicTypeVar(getTypeArgs(node, flags), typeParameters, node);
+        let typeArgs = adjustTypeArgumentsForVariadicTypeVar(getTypeArgs(node, flags), typeParameters, baseType.typeAliasInfo.typeVarScopeId, node);
         // PEP 612 says that if the class has only one type parameter consisting
         // of a ParamSpec, the list of arguments does not need to be enclosed in
         // a list. We'll handle that case specially here. Presumably this applies to
@@ -4324,7 +4343,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeVarContext = new typeVarContext_1.TypeVarContext(baseType.typeAliasInfo.typeVarScopeId);
         const diag = new diagnostic_1.DiagnosticAddendum();
         typeParameters.forEach((param, index) => {
-            var _a;
             if (param.details.isParamSpec && index < typeArgs.length) {
                 const typeArgType = typeArgs[index].type;
                 if (typeArgs[index].typeList) {
@@ -4387,9 +4405,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (index < typeArgs.length && typeArgs[index].typeList) {
                     addError(localize_1.Localizer.Diagnostic.typeArgListNotAllowed(), typeArgs[index].node);
                 }
-                const typeArgType = index < typeArgs.length
-                    ? (0, typeUtils_1.convertToInstance)(typeArgs[index].type)
-                    : (_a = param.details.defaultType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+                let typeArgType;
+                if (index < typeArgs.length) {
+                    typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
+                }
+                else if (param.details.defaultType) {
+                    typeArgType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
+                }
+                else {
+                    typeArgType = types_1.UnknownType.create();
+                }
                 (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, typeArgType, diag, typeVarContext, 128 /* RetainLiteralsForTypeVar */);
             }
         });
@@ -4400,8 +4425,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         (_b = baseType.typeAliasInfo.typeParameters) === null || _b === void 0 ? void 0 : _b.forEach((typeParam) => {
             let typeVarType;
             if ((0, types_1.isParamSpec)(typeParam)) {
-                const paramSpecValue = typeVarContext.getParamSpec(typeParam);
-                typeVarType = paramSpecValue ? (0, typeUtils_1.convertParamSpecValueToType)(paramSpecValue) : types_1.UnknownType.create();
+                const paramSpecType = typeVarContext.getParamSpecType(typeParam);
+                typeVarType = paramSpecType ? (0, typeUtils_1.convertParamSpecValueToType)(paramSpecType) : types_1.UnknownType.create();
             }
             else {
                 typeVarType = typeVarContext.getTypeVarType(typeParam);
@@ -4425,7 +4450,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = baseTypeResult.isIncomplete;
         const type = mapSubtypesExpandTypeVars(baseTypeResult.type, 
         /* conditionFilter */ undefined, (concreteSubtype, unexpandedSubtype) => {
-            var _a;
+            var _a, _b;
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
                 return concreteSubtype;
             }
@@ -4492,7 +4517,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const isClassVarAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'ClassVar');
                 let typeArgs = getTypeArgs(node, flags, isAnnotatedClass, hasCustomClassGetItem || !isGenericClass, isFinalAnnotation, isClassVarAnnotation);
                 if (!isAnnotatedClass) {
-                    typeArgs = adjustTypeArgumentsForVariadicTypeVar(typeArgs, concreteSubtype.details.typeParameters, node);
+                    typeArgs = adjustTypeArgumentsForVariadicTypeVar(typeArgs, concreteSubtype.details.typeParameters, (_b = (0, typeUtils_1.getTypeVarScopeId)(concreteSubtype)) !== null && _b !== void 0 ? _b : '', node);
                 }
                 // If this is a custom __class_getitem__, there's no need to specialize the class.
                 // Just return it as is.
@@ -4950,6 +4975,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
         /* flags */ undefined, index < expectedTypes.length ? expectedTypes[index] : undefined));
+        const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
         /* isTypeArgumentExplicit */ true));
         // Copy any expected type diag addenda for precision error reporting.
@@ -4962,7 +4988,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        return { type, expectedTypeDiagAddendum };
+        return { type, expectedTypeDiagAddendum, isIncomplete };
     }
     function getTypeOfTupleInferred(node) {
         const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
@@ -5478,7 +5504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isTypeIncomplete = true;
         }
         return {
-            argumentErrors: false,
+            argumentErrors: finalCallResult.argumentErrors,
             isArgumentAnyOrUnknown: finalCallResult.isArgumentAnyOrUnknown,
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
@@ -5622,7 +5648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Replace the result with an unknown type since we don't know
             // what overload should have been used.
             result.returnType = types_1.UnknownType.create();
-            return result;
+            return { ...result, argumentErrors: true };
         }
         return { argumentErrors: true, isTypeIncomplete: false };
     }
@@ -5900,10 +5926,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 useSpeculativeMode(errorNode, () => {
                     callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext.clone(), skipUnknownArgCheck);
                 });
-                if (!(callResult === null || callResult === void 0 ? void 0 : callResult.argumentErrors)) {
+                if (!callResult.argumentErrors) {
                     // Call validateCallArguments again, this time without speculative
                     // mode, so any errors are reported.
-                    const callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
+                    callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
                     if (callResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
@@ -5949,7 +5975,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 unsolvedTypeVarsAreUnknown = false;
             }
         }
-        const specializedType = (0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, unsolvedTypeVarsAreUnknown);
+        const specializedType = (0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, {
+            unknownIfNotFound: unsolvedTypeVarsAreUnknown,
+        });
         return types_1.ClassType.cloneAsInstance(specializedType);
     }
     // Similar to applyExpectedTypeForConstructor, this function handles the
@@ -7334,15 +7362,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // the call below to adjustCallableReturnType will "detach" these
         // TypeVars from the scope of this function and "attach" them to
         // the scope of the callable.
-        let unknownIfUnsolved = !(0, types_1.isFunction)(returnType);
+        let unknownIfNotFound = !(0, types_1.isFunction)(returnType);
         // We'll also leave TypeVars unsolved if the call is a recursive
         // call to a generic function.
         const typeVarScopes = getTypeVarScopesForNode(errorNode);
         if (typeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope))) {
-            unknownIfUnsolved = false;
+            unknownIfNotFound = false;
         }
-        let specializedReturnType = (0, typeUtils_1.addConditionToType)((0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, unknownIfUnsolved, 
-        /* useNarrowBoundOnly */ false, eliminateUnsolvedInUnions), typeCondition);
+        let specializedReturnType = (0, typeUtils_1.addConditionToType)((0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
+            unknownIfNotFound,
+            useUnknownOverDefault: skipUnknownArgCheck,
+            eliminateUnsolvedInUnions,
+        }), typeCondition);
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
@@ -7409,16 +7440,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // signature bound to the specified ParamSpec. Return value indicates success.
     function validateFunctionArgumentsForParamSpec(errorNode, argList, paramSpec, destTypeVarContext, conditionFilter) {
         var _a;
-        const paramSpecValue = destTypeVarContext.getParamSpec(paramSpec);
-        const srcTypeVarContext = new typeVarContext_1.TypeVarContext(paramSpecValue === null || paramSpecValue === void 0 ? void 0 : paramSpecValue.typeVarScopeId);
-        if (!paramSpecValue) {
+        const paramSpecType = destTypeVarContext.getParamSpecType(paramSpec);
+        if (!paramSpecType) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotBound().format({ type: printType(paramSpec) }), ((_a = argList[0]) === null || _a === void 0 ? void 0 : _a.valueExpression) || errorNode);
             return false;
         }
+        const srcTypeVarContext = new typeVarContext_1.TypeVarContext(paramSpecType.details.typeVarScopeId);
         let reportedArgError = false;
         // Build a map of all named parameters.
         const paramMap = new Map();
-        const paramSpecParams = paramSpecValue.parameters;
+        const paramSpecParams = paramSpecType.details.parameters;
         paramSpecParams.forEach((param) => {
             if (param.name) {
                 paramMap.set(param.name, param);
@@ -7499,7 +7530,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const paramInfo = paramMap.get(name);
                 return paramInfo.category === 0 /* Simple */ && !paramInfo.hasDefault;
             });
-            if (unassignedParams.length > 0 && !paramSpecValue.paramSpec) {
+            if (unassignedParams.length > 0 && !paramSpecType.details.paramSpec) {
                 const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
                     ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
@@ -7531,8 +7562,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 functionType !== undefined &&
                 argParam.paramType.scopeId === functionType.details.typeVarScopeId
                 ? undefined
-                : (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, 
-                /* unknownIfNotFound */ false, useNarrowBoundOnly);
+                : (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, { useNarrowBoundOnly });
             // If the expected type is unknown, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
             if (expectedType && (0, types_1.isUnknown)(expectedType)) {
@@ -7561,7 +7591,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argument &&
                 argParam.argument.name &&
                 !speculativeTypeTracker.isSpeculative(argParam.errorNode)) {
-                writeTypeCache(argParam.argument.name, expectedType || argType, 0 /* None */, isTypeIncomplete);
+                writeTypeCache(argParam.argument.name, { type: expectedType || argType, isIncomplete: isTypeIncomplete }, 0 /* None */);
             }
         }
         else {
@@ -7851,8 +7881,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // or constraint.
         if (typeVar.details.defaultType && defaultValueNode) {
             const typeVarContext = new typeVarContext_1.TypeVarContext(types_1.WildcardTypeVarScopeId);
-            const concreteDefaultType = (0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, 
-            /* unknownIfNotFound */ true);
+            const concreteDefaultType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
+                unknownIfNotFound: true,
+            }));
             if (typeVar.details.boundType) {
                 if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultBoundMismatch(), defaultValueNode);
@@ -7966,7 +7997,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // Update the type cache so we don't attempt to re-evaluate this node.
             // The type doesn't matter, so use Any.
-            writeTypeCache(node, types_1.AnyType.create(), /* flags */ undefined, /* isIncomplete */ false);
+            writeTypeCache(node, { type: types_1.AnyType.create() }, /* flags */ undefined);
             return functionType;
         }
         else {
@@ -8011,62 +8042,67 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // in the Python specification: The static type checker will treat
     // the new type as if it were a subclass of the original type.
     function createNewType(errorNode, argList) {
+        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-        let className = '_';
-        if (argList.length >= 1) {
-            const nameArg = argList[0];
-            if (nameArg.argumentCategory === 0 /* Simple */) {
-                if (nameArg.valueExpression && nameArg.valueExpression.nodeType === 48 /* StringList */) {
-                    className = nameArg.valueExpression.strings.map((s) => s.value).join('');
-                }
-            }
-        }
-        if (argList.length >= 2) {
-            const baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
-            if ((0, types_1.isInstantiableClass)(baseClass)) {
-                if (types_1.ClassType.isProtocolClass(baseClass)) {
-                    addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
-                }
-                else if (baseClass.literalValue !== undefined) {
-                    addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
-                }
-                const classFlags = baseClass.details.flags & ~(1 /* BuiltInClass */ | 2 /* SpecialBuiltIn */);
-                const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
-                /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
-                classType.details.baseClasses.push(baseClass);
-                (0, typeUtils_1.computeMroLinearization)(classType);
-                // Synthesize an __init__ method that accepts only the specified type.
-                const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
-                types_1.FunctionType.addParameter(initType, {
-                    category: 0 /* Simple */,
-                    name: 'self',
-                    type: types_1.ClassType.cloneAsInstance(classType),
-                    hasDeclaredType: true,
-                });
-                types_1.FunctionType.addParameter(initType, {
-                    category: 0 /* Simple */,
-                    name: '_x',
-                    type: types_1.ClassType.cloneAsInstance(baseClass),
-                    hasDeclaredType: true,
-                });
-                initType.details.declaredReturnType = types_1.NoneType.createInstance();
-                classType.details.fields.set('__init__', symbol_1.Symbol.createWithType(4 /* ClassMember */, initType));
-                // Synthesize a trivial __new__ method.
-                const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
-                types_1.FunctionType.addParameter(newType, {
-                    category: 0 /* Simple */,
-                    name: 'cls',
-                    type: classType,
-                    hasDeclaredType: true,
-                });
-                types_1.FunctionType.addDefaultParameters(newType);
-                newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
-                classType.details.fields.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
-                return classType;
-            }
-            else if (!(0, types_1.isAnyOrUnknown)(baseClass)) {
-                addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
-            }
+        let className = '';
+        if (argList.length !== 2) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeParamCount(), errorNode);
+            return undefined;
+        }
+        const nameArg = argList[0];
+        if (nameArg.argumentCategory === 0 /* Simple */ &&
+            nameArg.valueExpression &&
+            nameArg.valueExpression.nodeType === 48 /* StringList */) {
+            className = nameArg.valueExpression.strings.map((s) => s.value).join('');
+        }
+        if (!className) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
+            return undefined;
+        }
+        const baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
+        if ((0, types_1.isInstantiableClass)(baseClass)) {
+            if (types_1.ClassType.isProtocolClass(baseClass)) {
+                addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
+            }
+            else if (baseClass.literalValue !== undefined) {
+                addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
+            }
+            const classFlags = baseClass.details.flags & ~(1 /* BuiltInClass */ | 2 /* SpecialBuiltIn */);
+            const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
+            /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
+            classType.details.baseClasses.push(baseClass);
+            (0, typeUtils_1.computeMroLinearization)(classType);
+            // Synthesize an __init__ method that accepts only the specified type.
+            const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
+            types_1.FunctionType.addParameter(initType, {
+                category: 0 /* Simple */,
+                name: 'self',
+                type: types_1.ClassType.cloneAsInstance(classType),
+                hasDeclaredType: true,
+            });
+            types_1.FunctionType.addParameter(initType, {
+                category: 0 /* Simple */,
+                name: '_x',
+                type: types_1.ClassType.cloneAsInstance(baseClass),
+                hasDeclaredType: true,
+            });
+            initType.details.declaredReturnType = types_1.NoneType.createInstance();
+            classType.details.fields.set('__init__', symbol_1.Symbol.createWithType(4 /* ClassMember */, initType));
+            // Synthesize a trivial __new__ method.
+            const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
+            types_1.FunctionType.addParameter(newType, {
+                category: 0 /* Simple */,
+                name: 'cls',
+                type: classType,
+                hasDeclaredType: true,
+            });
+            types_1.FunctionType.addDefaultParameters(newType);
+            newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
+            classType.details.fields.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
+            return classType;
+        }
+        if (!(0, types_1.isAnyOrUnknown)(baseClass)) {
+            addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
         }
         return undefined;
     }
@@ -8261,7 +8297,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (node.operator === 6 /* BitwiseOr */) {
                 // If this is a bitwise or ("|"), use the type of the left operand. This allows
                 // us to support the case where a TypedDict is being updated with a dict expression.
-                expectedOperandType = leftType;
+                if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isTypedDictClass(leftType)) {
+                    expectedOperandType = leftType;
+                }
             }
         }
         const rightTypeResult = getTypeOfExpression(rightExpression, flags, expectedOperandType);
@@ -9395,7 +9433,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         functionType.details.typeVarScopeId = getScopeIdForNode(node);
         // Pre-cache the incomplete function type in case the evaluation of the
         // lambda depends on itself.
-        writeTypeCache(node, functionType, 0 /* None */, /* isIncomplete */ true);
+        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         let expectedFunctionTypes = [];
         if (expectedType) {
             (0, typeUtils_1.mapSubtypes)(expectedType, (subtype) => {
@@ -9432,8 +9470,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 paramType = types_1.FunctionType.getEffectiveParameterType(expectedFunctionType, index);
             }
             if (param.name) {
-                writeTypeCache(param.name, transformVariadicParamType(node, param.category, paramType), 0 /* None */, 
-                /* isIncomplete */ false);
+                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType) }, 0 /* None */);
             }
             if (param.defaultValue) {
                 // Evaluate the default value if it's present.
@@ -9498,8 +9535,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (speculativeTypeTracker.isSpeculative(node)) {
             useSpeculativeMode(node.expression, () => {
                 inferLambdaReturnType();
-            }, 
-            /* allowCacheRetention */ false);
+            });
         }
         else {
             inferLambdaReturnType();
@@ -10371,7 +10407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForTypeAlias(type, name, errorNode, typeParameters) {
+    function transformTypeForTypeAlias(type, name, errorNode, typeParameters, typeParamNodes) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
         }
@@ -10400,6 +10436,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return (0, typeUtils_1.convertToInstance)(typeVar);
         });
+        // Validate the default types for all type parameters.
+        typeParameters.forEach((typeParam, index) => {
+            var _a;
+            let bestErrorNode = errorNode;
+            if (typeParamNodes && index < typeParamNodes.length) {
+                bestErrorNode = (_a = typeParamNodes[index].defaultExpression) !== null && _a !== void 0 ? _a : typeParamNodes[index].name;
+            }
+            validateTypeParameterDefault(bestErrorNode, typeParam, typeParameters.slice(0, index));
+        });
         // Verify that we have at most one variadic type variable.
         const variadics = typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
         if (variadics.length > 1) {
@@ -10514,7 +10559,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specialType.details.baseClasses.push(strClassType !== null && strClassType !== void 0 ? strClassType : types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
             }
-            writeTypeCache(node, specialType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node, { type: specialType }, 0 /* None */);
             return specialType;
         }
         return undefined;
@@ -10594,7 +10639,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
                 rightHandType = handleTypingStubAssignment(node);
                 if (rightHandType) {
-                    writeTypeCache(node.rightExpression, rightHandType, 0 /* None */, /* isIncomplete */ false);
+                    writeTypeCache(node.rightExpression, { type: rightHandType }, 0 /* None */);
                 }
             }
             if (!rightHandType) {
@@ -10632,14 +10677,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
                     typeAliasTypeVar.scopeId = scopeId;
                     // Write the type back to the type cache. It will be replaced below.
-                    writeTypeCache(node, typeAliasTypeVar, /* flags */ undefined, /* isIncomplete */ false);
-                    writeTypeCache(node.leftExpression, typeAliasTypeVar, 
-                    /* flags */ undefined, 
-                    /* isIncomplete */ false);
+                    writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
+                    writeTypeCache(node.leftExpression, { type: typeAliasTypeVar }, /* flags */ undefined);
                     if (node.leftExpression.nodeType === 54 /* TypeAnnotation */) {
-                        writeTypeCache(node.leftExpression.valueExpression, typeAliasTypeVar, 
-                        /* flags */ undefined, 
-                        /* isIncomplete */ false);
+                        writeTypeCache(node.leftExpression.valueExpression, { type: typeAliasTypeVar }, 
+                        /* flags */ undefined);
                     }
                 }
                 const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, declaredType);
@@ -10708,7 +10750,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToExpression(node.leftExpression, rightHandType, isIncomplete, node.rightExpression, 
         /* ignoreEmptyContainers */ true, 
         /* allowAssignmentToFinalVar */ true, expectedTypeDiagAddendum);
-        writeTypeCache(node, rightHandType, 0 /* None */, isIncomplete);
+        writeTypeCache(node, { type: rightHandType, isIncomplete }, 0 /* None */);
     }
     function isPossibleTypeAliasOrTypedDict(decl) {
         var _a;
@@ -10741,6 +10783,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // path does not handle traditional type aliases, which are treated as
     // variables since they use normal variable assignment syntax.
     function getTypeOfTypeAlias(node) {
+        var _a;
         const cachedType = readTypeCache(node.name, 0 /* None */);
         if (cachedType) {
             return cachedType;
@@ -10754,7 +10797,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
-        writeTypeCache(node.name, typeAliasTypeVar, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
         const scope = ScopeUtils.getScopeForNode(node);
         const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(node.name.value);
@@ -10778,7 +10821,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Clear the temporary type we wrote above.
         deleteTypeCacheEntry(node.name);
-        aliasType = transformTypeForTypeAlias(aliasType, node.name, node.expression, typeParameters);
+        aliasType = transformTypeForTypeAlias(aliasType, node.name, node.expression, typeParameters, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
                 name: node.name.value,
@@ -10793,7 +10836,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 name: node.name.value,
             }), node.name);
         }
-        writeTypeCache(node.name, aliasType, 0 /* None */, isIncomplete);
+        writeTypeCache(node.name, { type: aliasType, isIncomplete }, 0 /* None */);
         return aliasType;
     }
     function evaluateTypesForAugmentedAssignment(node) {
@@ -10801,7 +10844,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return;
         }
         const destTypeResult = getTypeOfAugmentedAssignment(node, /* expectedType */ undefined);
-        writeTypeCache(node, destTypeResult.type, 0 /* None */, !!destTypeResult.isIncomplete);
+        writeTypeCache(node, destTypeResult, 0 /* None */);
     }
     function getPseudoGenericTypeVarName(paramName) {
         return `__type_of_${paramName}`;
@@ -10860,8 +10903,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
         classType.details.flags |= 131072 /* PartiallyEvaluated */;
-        writeTypeCache(node, classType, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, classType, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: classType }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: classType }, /* flags */ undefined);
         // Keep a list of unique type parameters that are used in the
         // base class arguments.
         let typeParameters = [];
@@ -11096,6 +11139,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 names: variadics.map((v) => `"${v.details.name}"`).join(', '),
             }), node.name, textRange_1.TextRange.combine(node.arguments) || node.name);
         }
+        // Validate the default types for all type parameters.
+        classType.details.typeParameters.forEach((typeParam, index) => {
+            var _a;
+            let bestErrorNode = node.name;
+            if (node.typeParameters && index < node.typeParameters.parameters.length) {
+                const typeParamNode = node.typeParameters.parameters[index];
+                bestErrorNode = (_a = typeParamNode.defaultExpression) !== null && _a !== void 0 ? _a : typeParamNode.name;
+            }
+            validateTypeParameterDefault(bestErrorNode, typeParam, classType.details.typeParameters.slice(0, index));
+        });
         if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
             addError(localize_1.Localizer.Diagnostic.methodOrdering(), node.name);
         }
@@ -11274,9 +11327,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Update the undecorated class type.
-        writeTypeCache(node.name, classType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: classType }, 0 /* None */);
         // Update the decorated class type.
-        writeTypeCache(node, decoratedType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
         // Stash away a reference to the UnionType class if we encounter it.
         // There's no easy way to otherwise reference it.
         if (types_1.ClassType.isBuiltIn(classType, 'UnionType')) {
@@ -11284,6 +11337,36 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { classType, decoratedType };
     }
+    // Determines whether the type parameters has a default that refers to another
+    // type parameter. If so, validates that it is in the list of "live" type
+    // parameters and updates the scope of the type parameter referred to in the
+    // default type expression.
+    function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams) {
+        if (!typeParam.details.defaultType &&
+            !typeParam.details.isSynthesized &&
+            !typeParam.details.isSynthesizedSelf) {
+            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType);
+            if (typeVarWithDefault) {
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarWithoutDefault().format({
+                    name: typeParam.details.name,
+                    other: typeVarWithDefault.details.name,
+                }), errorNode);
+            }
+            return;
+        }
+        const invalidTypeVars = new Set();
+        (0, typeUtils_1.validateTypeVarDefault)(typeParam, otherLiveTypeParams, invalidTypeVars);
+        // If we found one or more unapplied type variable, report an error.
+        if (invalidTypeVars.size > 0) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            invalidTypeVars.forEach((name) => {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarDefaultOutOfScope().format({ name }));
+            });
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultInvalidTypeVar().format({
+                name: typeParam.details.name,
+            }) + diag.getString(), errorNode);
+        }
+    }
     function inferTypeParameterVarianceForClass(classType) {
         if (!classType.details.requiresVarianceInference) {
             return;
@@ -11360,7 +11443,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
                 return;
             }
-            writeTypeCache(param.name, typeOfParam, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(param.name, { type: typeOfParam }, 0 /* None */);
             paramTypes.push(typeOfParam);
         });
         return paramTypes;
@@ -11590,6 +11673,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
     }
     function getTypeOfFunction(node) {
+        var _a, _b;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // Is this type already cached?
         const cachedFunctionType = readTypeCache(node.name, 0 /* None */);
@@ -11658,8 +11742,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (functionDecl && functionSymbol) {
             setSymbolResolutionPartialType(functionSymbol.symbol, functionDecl, functionType);
         }
-        writeTypeCache(node, functionType, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, functionType, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: functionType }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: functionType }, /* flags */ undefined);
         // Is this an "__init__" method within a pseudo-generic class? If so,
         // we'll add generic types to the constructor's parameters.
         const addGenericParamTypes = containingClassType &&
@@ -11689,8 +11773,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }), node.functionAnnotationComment);
             }
         }
+        // If this function uses PEP 695 syntax for type parameters,
+        // accumulate the list of type parameters upfront.
+        const typeParametersSeen = [];
         if (node.typeParameters) {
-            evaluateTypeParameterList(node.typeParameters);
+            functionType.details.typeParameters = evaluateTypeParameterList(node.typeParameters);
+        }
+        else {
+            functionType.details.typeParameters = typeParametersSeen;
         }
         const markParamAccessed = (param) => {
             if (param.name) {
@@ -11838,6 +11928,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isTypeInferred,
             };
             types_1.FunctionType.addParameter(functionType, functionParam);
+            if (functionParam.hasDeclaredType) {
+                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionParam.type));
+            }
             if (param.name) {
                 const variadicParamType = transformVariadicParamType(node, param.category, functionParam.type);
                 paramTypes.push(variadicParamType);
@@ -11860,7 +11953,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isUnknown)(paramType)) {
                     functionType.details.flags |= 16384 /* UnannotatedParams */;
                 }
-                writeTypeCache(paramNameNode, paramType, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(paramNameNode, { type: paramType }, 0 /* None */);
             }
         });
         // If the function ends in P.args and P.kwargs parameters, make it exempt from
@@ -11878,19 +11971,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If there was a defined return type, analyze that first so when we
         // walk the contents of the function, return statements can be
         // validated against this type.
-        if (node.returnTypeAnnotation) {
-            // Temporarily set the return type to unknown in case of recursion.
-            functionType.details.declaredReturnType = types_1.UnknownType.create();
-            const returnType = getTypeOfAnnotation(node.returnTypeAnnotation, {
-                associateTypeVarsWithScope: true,
-                disallowRecursiveTypeAlias: true,
-            });
-            functionType.details.declaredReturnType = returnType;
-        }
-        else if (node.functionAnnotationComment) {
+        const returnTypeAnnotationNode = (_a = node.returnTypeAnnotation) !== null && _a !== void 0 ? _a : (_b = node.functionAnnotationComment) === null || _b === void 0 ? void 0 : _b.returnTypeAnnotation;
+        if (returnTypeAnnotationNode) {
             // Temporarily set the return type to unknown in case of recursion.
             functionType.details.declaredReturnType = types_1.UnknownType.create();
-            const returnType = getTypeOfAnnotation(node.functionAnnotationComment.returnTypeAnnotation, {
+            const returnType = getTypeOfAnnotation(returnTypeAnnotationNode, {
                 associateTypeVarsWithScope: true,
                 disallowRecursiveTypeAlias: true,
             });
@@ -11911,6 +11996,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        // Accumulate any type parameters used in the return type.
+        if (functionType.details.declaredReturnType && returnTypeAnnotationNode) {
+            rescopeTypeVarsForCallableReturnType(functionType.details.declaredReturnType, functionType, typeParametersSeen);
+        }
         // If the return type is explicitly annotated as a generator, mark the
         // function as a generator even though it may not contain a "yield" statement.
         // This is important for generator functions declared in stub files, abstract
@@ -11926,6 +12015,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 functionType.details.flags |= 16 /* Generator */;
             }
         }
+        // Validate the default types for all type parameters.
+        functionType.details.typeParameters.forEach((typeParam, index) => {
+            var _a;
+            let bestErrorNode = node.name;
+            if (node.typeParameters && index < node.typeParameters.parameters.length) {
+                const typeParamNode = node.typeParameters.parameters[index];
+                bestErrorNode = (_a = typeParamNode.defaultExpression) !== null && _a !== void 0 ? _a : typeParamNode.name;
+            }
+            validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index));
+        });
         // Clear the "partially evaluated" flag to indicate that the functionType
         // is fully evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
@@ -11959,10 +12058,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             decoratedType = addOverloadsToFunctionType(node, decoratedType);
         }
-        writeTypeCache(node.name, functionType, 0 /* None */, /* isIncomplete */ false);
-        writeTypeCache(node, decoratedType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: functionType }, 0 /* None */);
+        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
         return { functionType, decoratedType };
     }
+    // If the declared return type of a function contains type variables that
+    // are found nowhere else in the signature and are contained within a
+    // Callable, these type variables are "rescoped" from the function to
+    // the Callable.
+    function rescopeTypeVarsForCallableReturnType(returnType, functionType, typeParametersSeen) {
+        const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
+        const rescopedTypeVars = [];
+        typeVarsInReturnType.forEach((typeVar) => {
+            if (types_1.TypeBase.isInstantiable(typeVar)) {
+                typeVar = types_1.TypeVarType.cloneAsInstance(typeVar);
+            }
+            // If this type variable isn't scoped to this function, it is probably
+            // associated with an outer scope.
+            if (typeVar.scopeId !== functionType.details.typeVarScopeId) {
+                return;
+            }
+            // If this type variable was already seen in one or more input parameters,
+            // don't attempt to rescope it.
+            if (typeParametersSeen.some((tp) => (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(tp), typeVar))) {
+                return;
+            }
+            // Is this type variable seen outside of a single callable?
+            if ((0, typeUtils_1.isTypeVarLimitedToCallable)(returnType, typeVar)) {
+                rescopedTypeVars.push(typeVar);
+            }
+        });
+        (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, typeVarsInReturnType);
+        // Note that the type parameters have been rescoped so they are not
+        // considered valid for the body of this function.
+        functionType.details.rescopedTypeParameters = rescopedTypeVars;
+    }
     function adjustParameterAnnotatedType(param, type) {
         var _a;
         // PEP 484 indicates that if a parameter has a default value of 'None'
@@ -12509,7 +12639,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                writeTypeCache(node.suite, inferredReturnType, 0 /* None */, isIncomplete);
+                writeTypeCache(node.suite, { type: inferredReturnType, isIncomplete }, 0 /* None */);
             }
             finally {
                 functionRecursionMap.delete(node.id);
@@ -12552,7 +12682,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         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);
-        writeTypeCache(node, iteratedType, 0 /* None */, !!iteratorTypeResult.isIncomplete);
+        writeTypeCache(node, { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForExceptStatement(node) {
         // This should be called only if the except node has a target exception.
@@ -12602,7 +12732,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.name) {
             assignTypeToExpression(node.name, targetType, /* isIncomplete */ false, node.name);
         }
-        writeTypeCache(node, targetType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: targetType }, 0 /* None */);
     }
     function evaluateTypesForWithStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12667,7 +12797,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.target) {
             assignTypeToExpression(node.target, scopedType, !!exprTypeResult.isIncomplete, node.target);
         }
-        writeTypeCache(node, scopedType, 0 /* None */, !!exprTypeResult.isIncomplete);
+        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportAs(node) {
         var _a;
@@ -12699,7 +12829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForImportFromAs(node) {
         var _a;
@@ -12756,7 +12886,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(aliasNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForMatchStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12771,7 +12901,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* isPositiveTest */ false);
             }
         }
-        writeTypeCache(node, subjectType, 0 /* None */, !!subjectTypeResult.isIncomplete);
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForCaseStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12805,7 +12935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         subjectType = (0, patternMatching_1.narrowTypeBasedOnPattern)(evaluatorInterface, subjectType, node.pattern, 
         /* isPositiveTest */ true);
         (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, subjectIsObject, node.pattern);
-        writeTypeCache(node, subjectType, 0 /* None */, !!subjectTypeResult.isIncomplete);
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportFrom(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12827,7 +12957,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForTypeAnnotationNode(node) {
         var _a;
@@ -12843,7 +12973,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
                 allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
             });
-            writeTypeCache(node.valueExpression, annotationType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node.valueExpression, { type: annotationType }, 0 /* None */);
         }
     }
     function getAliasedSymbolTypeForName(node, name) {
@@ -13180,7 +13310,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const param = functionNode.parameters[paramIndex];
             const annotatedType = getTypeOfParameterAnnotation(typeAnnotation, functionNode.parameters[paramIndex].category);
             const adjType = transformVariadicParamType(node, node.category, adjustParameterAnnotatedType(param, annotatedType));
-            writeTypeCache(node.name, adjType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node.name, { type: adjType }, 0 /* None */);
             return;
         }
         const containingClassNode = ParseTreeUtils.getEnclosingClass(functionNode, /* stopAtFunction */ true);
@@ -13191,7 +13321,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeParamName = getPseudoGenericTypeVarName(node.name.value);
             const paramType = classInfo.classType.details.typeParameters.find((param) => param.details.name === typeParamName);
             if (paramType) {
-                writeTypeCache(node.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node.name, { type: paramType }, 0 /* None */);
                 return;
             }
         }
@@ -13200,8 +13330,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // a parent class if it has an annotated type.
         const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
         const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
-        writeTypeCache(node.name, transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()), 0 /* None */, 
-        /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* None */);
     }
     // Evaluates the types that are assigned within the statement that contains
     // the specified parse node. In some cases, a broader statement may need to
@@ -13311,36 +13440,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // within that tree. If the type cannot be determined (because it's part
     // of a cyclical dependency), the function returns undefined.
     function evaluateTypeForSubnode(subnode, callback) {
-        // If the type cache is already populated, don't bother
-        // doing additional work.
-        let subnodeType = readTypeCache(subnode, /* flags */ undefined);
-        if (subnodeType) {
-            return { type: subnodeType };
-        }
-        const oldIncompleteCache = incompleteTypeCache;
-        try {
-            // If there isn't already an incompleteTypeCache allocated, allocate
-            // one now. We'll use this same cache for nested calls, but we'll
-            // abandon it once the last nested call completes.
-            if (!incompleteTypeCache) {
-                incompleteTypeCache = new Map();
-            }
-            callback();
-            subnodeType = readTypeCache(subnode, /* flags */ undefined);
-            if (subnodeType) {
-                return { type: subnodeType };
-            }
-            subnodeType = incompleteTypeCache.get(subnode.id);
-            if (subnodeType) {
-                return { type: subnodeType, isIncomplete: true };
-            }
-            incompleteTypeCache = oldIncompleteCache;
-        }
-        catch (e) {
-            // We don't use a finally clause here because the debugger doesn't
-            // handle it well when stepping through code.
-            incompleteTypeCache = oldIncompleteCache;
-            throw e;
+        // If the type cache is already populated with a complete type,
+        // don't bother doing additional work.
+        let cacheEntry = readTypeCacheEntry(subnode);
+        if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
+            return { type: cacheEntry.typeResult.type };
+        }
+        callback();
+        cacheEntry = readTypeCacheEntry(subnode);
+        if (cacheEntry) {
+            return {
+                type: cacheEntry.typeResult.type,
+                isIncomplete: cacheEntry.typeResult.isIncomplete,
+                expectedTypeDiagAddendum: cacheEntry.typeResult.expectedTypeDiagAddendum,
+            };
         }
         return undefined;
     }
@@ -13605,8 +13718,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        const typeVarContext = new typeVarContext_1.TypeVarContext(classType.details.typeVarScopeId);
         fullTypeParams.forEach((typeParam, index) => {
-            var _a;
             if (typeArgs && index < typeArgs.length) {
                 if (typeParam.details.isParamSpec) {
                     const typeArg = typeArgs[index];
@@ -13616,6 +13729,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         types_1.FunctionType.addDefaultParameters(functionType);
                         functionType.details.flags |= 32768 /* SkipArgsKwargsCompatibilityCheck */;
                         typeArgTypes.push(functionType);
+                        typeVarContext.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(functionType));
                         return;
                     }
                     if (typeArg.typeList) {
@@ -13629,6 +13743,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             });
                         });
                         typeArgTypes.push(functionType);
+                        typeVarContext.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(functionType));
                         return;
                     }
                     if ((0, types_1.isInstantiableClass)(typeArg.type) && types_1.ClassType.isBuiltIn(typeArg.type, 'Concatenate')) {
@@ -13655,10 +13770,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return;
                     }
                 }
-                typeArgTypes.push((0, typeUtils_1.convertToInstance)(typeArgs[index].type));
+                const typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
+                typeArgTypes.push(typeArgType);
+                typeVarContext.setTypeVarType(typeParam, typeArgType);
                 return;
             }
-            typeArgTypes.push((_a = typeParam.details.defaultType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create());
+            const solvedDefaultType = (0, typeUtils_1.applySolvedTypeVars)(typeParam, typeVarContext, { unknownIfNotFound: true });
+            typeArgTypes.push(solvedDefaultType);
+            if ((0, types_1.isParamSpec)(typeParam)) {
+                typeVarContext.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(solvedDefaultType));
+            }
+            else {
+                typeVarContext.setTypeVarType(typeParam, solvedDefaultType);
+            }
         });
         typeArgTypes = typeArgTypes.map((typeArgType, index) => {
             if (index < typeArgCount) {
@@ -13880,8 +14004,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Disables recording of errors and warnings and disables
     // any caching of types, under the assumption that we're
     // performing speculative evaluations.
-    function useSpeculativeMode(speculativeNode, callback, allowCacheRetention = true) {
-        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, allowCacheRetention);
+    function useSpeculativeMode(speculativeNode, callback) {
+        speculativeTypeTracker.enterSpeculativeContext(speculativeNode);
         try {
             const result = callback();
             speculativeTypeTracker.leaveSpeculativeContext();
@@ -14198,65 +14322,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return undefined;
             }
             case 3 /* TypeParameter */: {
-                let typeVar = types_1.TypeVarType.createInstantiable(declaration.node.name.value);
-                if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-                    typeVar.details.isVariadic = true;
-                }
-                else if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
-                    typeVar.details.isParamSpec = true;
-                }
-                if (declaration.node.boundExpression) {
-                    if (declaration.node.boundExpression.nodeType === 52 /* Tuple */) {
-                        const constraints = declaration.node.boundExpression.expressions.map((constraint) => {
-                            const constraintType = getTypeOfExpressionExpectingType(constraint).type;
-                            if ((0, typeUtils_1.requiresSpecialization)(constraintType, /* ignorePseudoGeneric */ true)) {
-                                addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), constraint);
-                            }
-                            return (0, typeUtils_1.convertToInstance)(constraintType);
-                        });
-                        if (constraints.length < 2) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(declaration.node.boundExpression).diagnosticRuleSet
-                                .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarSingleConstraint(), declaration.node.boundExpression);
-                        }
-                        else if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
-                            typeVar.details.constraints = constraints;
-                        }
-                    }
-                    else {
-                        const boundType = getTypeOfExpressionExpectingType(declaration.node.boundExpression).type;
-                        if ((0, typeUtils_1.requiresSpecialization)(boundType, /* ignorePseudoGeneric */ true)) {
-                            addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), declaration.node.boundExpression);
-                        }
-                        if (declaration.node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
-                            typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(boundType);
-                        }
-                    }
-                }
-                if (declaration.node.defaultExpression) {
-                    // TODO - need to finish. For now, just evaluate the expression
-                    // to generate any errors.
-                    getTypeOfExpression(declaration.node.defaultExpression, 2097152 /* AllowUnpackedTupleOrTypeVarTuple */);
-                }
-                typeVar.details.isTypeParamSyntax = true;
-                // Associate the type variable with the owning scope.
-                const scopeNode = ParseTreeUtils.getTypeVarScopeNode(declaration.node);
-                if (scopeNode) {
-                    let scopeType;
-                    if (scopeNode.nodeType === 10 /* Class */) {
-                        scopeType = 0 /* Class */;
-                        // Set the variance to "auto" for class-scoped TypeVars.
-                        typeVar.details.declaredVariance = 0 /* Auto */;
-                    }
-                    else if (scopeNode.nodeType === 28 /* Function */) {
-                        scopeType = 1 /* Function */;
-                    }
-                    else {
-                        (0, debug_1.assert)(scopeNode.nodeType === 77 /* TypeAlias */);
-                        scopeType = 2 /* TypeAlias */;
-                    }
-                    typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, getScopeIdForNode(scopeNode.nodeType === 77 /* TypeAlias */ ? scopeNode.name : scopeNode), scopeNode.name.value, scopeType);
-                }
-                return typeVar;
+                return getTypeOfTypeParameter(declaration.node);
             }
             case 1 /* Variable */: {
                 const typeAnnotationNode = declaration.typeAnnotationNode;
@@ -14301,6 +14367,99 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
+    function getTypeOfTypeParameter(node) {
+        // Is this type already cached?
+        const cachedTypeVarType = readTypeCache(node.name, 0 /* None */);
+        if (cachedTypeVarType && (0, types_1.isTypeVar)(cachedTypeVarType)) {
+            return cachedTypeVarType;
+        }
+        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value);
+        typeVar.details.isTypeParamSyntax = true;
+        if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
+            typeVar.details.isVariadic = true;
+        }
+        else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
+            typeVar.details.isParamSpec = true;
+        }
+        // Cache the value before we evaluate the bound or the default type in
+        // case it refers to itself in a circular manner.
+        writeTypeCache(node, { type: typeVar }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: typeVar }, /* flags */ undefined);
+        if (node.boundExpression) {
+            if (node.boundExpression.nodeType === 52 /* Tuple */) {
+                const constraints = node.boundExpression.expressions.map((constraint) => {
+                    const constraintType = getTypeOfExpressionExpectingType(constraint).type;
+                    if ((0, typeUtils_1.requiresSpecialization)(constraintType, /* ignorePseudoGeneric */ true)) {
+                        addError(localize_1.Localizer.Diagnostic.typeVarBoundGeneric(), constraint);
+                    }
+                    return (0, typeUtils_1.convertToInstance)(constraintType);
+                });
+                if (constraints.length < 2) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node.boundExpression).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarSingleConstraint(), node.boundExpression);
+                }
+                else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
+                    typeVar.details.constraints = constraints;
+                }
+            }
+            else {
+                const boundType = getTypeOfExpressionExpectingType(node.boundExpression).type;
+                if ((0, typeUtils_1.requiresSpecialization)(boundType, /* ignorePseudoGeneric */ true)) {
+                    addError(localize_1.Localizer.Diagnostic.typeVarConstraintGeneric(), node.boundExpression);
+                }
+                if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVar) {
+                    typeVar.details.boundType = (0, typeUtils_1.convertToInstance)(boundType);
+                }
+            }
+        }
+        if (node.defaultExpression) {
+            if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
+                typeVar.details.defaultType = getParamSpecDefaultType(node.defaultExpression);
+            }
+            else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
+                typeVar.details.defaultType = getTypeVarTupleDefaultType(node.defaultExpression);
+            }
+            else {
+                typeVar.details.defaultType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression).type);
+            }
+        }
+        // If a default is provided, make sure it is compatible with the bound
+        // or constraint.
+        if (typeVar.details.defaultType && node.defaultExpression) {
+            const typeVarContext = new typeVarContext_1.TypeVarContext(types_1.WildcardTypeVarScopeId);
+            const concreteDefaultType = (0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
+                unknownIfNotFound: true,
+            });
+            if (typeVar.details.boundType) {
+                if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultBoundMismatch(), node.defaultExpression);
+                }
+            }
+            else if (typeVar.details.constraints.length > 0) {
+                if (!typeVar.details.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType))) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarDefaultConstraintMismatch(), node.defaultExpression);
+                }
+            }
+        }
+        // Associate the type variable with the owning scope.
+        const scopeNode = ParseTreeUtils.getTypeVarScopeNode(node);
+        if (scopeNode) {
+            let scopeType;
+            if (scopeNode.nodeType === 10 /* Class */) {
+                scopeType = 0 /* Class */;
+                // Set the variance to "auto" for class-scoped TypeVars.
+                typeVar.details.declaredVariance = 0 /* Auto */;
+            }
+            else if (scopeNode.nodeType === 28 /* Function */) {
+                scopeType = 1 /* Function */;
+            }
+            else {
+                (0, debug_1.assert)(scopeNode.nodeType === 77 /* TypeAlias */);
+                scopeType = 2 /* TypeAlias */;
+            }
+            typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, getScopeIdForNode(scopeNode.nodeType === 77 /* TypeAlias */ ? scopeNode.name : scopeNode), scopeNode.name.value, scopeType);
+        }
+        return typeVar;
+    }
     function getInferredTypeOfDeclaration(symbol, decl) {
         var _a, _b;
         const resolvedDecl = resolveAliasDeclaration(decl, 
@@ -14527,7 +14686,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
-        var _a;
+        var _a, _b;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
             const declaredType = getDeclaredTypeOfSymbol(symbol, usageNode);
@@ -14551,7 +14710,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Look in the cache to see if we've computed this already.
         let cacheEntries = effectiveTypeCache.get(symbol.id);
-        let evaluationAttempts = 0;
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
         if (cacheEntries) {
@@ -14560,7 +14718,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!result.isIncomplete) {
                     return result;
                 }
-                evaluationAttempts = ((_a = result.evaluationAttempts) !== null && _a !== void 0 ? _a : 0) + 1;
             }
         }
         // Infer the type.
@@ -14688,20 +14845,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     isIncomplete = true;
                     // Note that at least one decl could not be evaluated because
-                    // it was already in the process of being evaluated. Don't set
-                    // this flag if we've already attempted the type evaluation
-                    // many times because this probably means there's a cyclical
-                    // dependency that cannot be broken.
-                    if (evaluationAttempts < maxEffectiveTypeEvaluationAttempts) {
-                        sawPendingEvaluation = true;
-                    }
+                    // it was already in the process of being evaluated.
+                    sawPendingEvaluation = true;
                 }
             }
         });
         if (typesToCombine.length > 0) {
+            // How many times have we already attempted to evaluate this declaration already?
+            const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
+            // Ignore the pending evaluation flag if we've already attempted the
+            // type evaluation many times because this probably means there's a
+            // cyclical dependency that cannot be broken.
+            isIncomplete = sawPendingEvaluation && evaluationAttempts < maxEffectiveTypeEvaluationAttempts;
             const result = {
                 type: (0, types_1.combineTypes)(typesToCombine),
-                isIncomplete: sawPendingEvaluation,
+                isIncomplete,
                 includesVariableDecl,
                 includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
                 isRecursiveDefinition: false,
@@ -14723,7 +14881,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
             isRecursiveDefinition: false,
-            evaluationAttempts,
         };
     }
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
@@ -14982,7 +15139,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType = types_1.UnknownType.create();
                         }
                         paramTypes.push(paramType);
-                        writeTypeCache(param.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                        writeTypeCache(param.name, { type: paramType }, 0 /* None */);
                     }
                 });
                 // Don't bother trying to determine the contextual return
@@ -16436,9 +16593,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let specializedDestType = destType;
         let reverseMatchingFailed = false;
         if ((flags & 2 /* ReverseTypeVarMatching */) === 0) {
-            specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, 
-            /* unknownIfNotFound */ undefined, 
-            /* useNarrowBoundOnly */ true);
+            specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, { useNarrowBoundOnly: true });
             if ((0, typeUtils_1.requiresSpecialization)(specializedDestType)) {
                 reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
                 /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) |
@@ -16448,9 +16603,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else {
-            specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, 
-            /* unknownIfNotFound */ undefined, 
-            /* useNarrowBoundOnly */ true);
+            specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, { useNarrowBoundOnly: true });
             if ((0, typeUtils_1.requiresSpecialization)(specializedSrcType)) {
                 reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
                 /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) |
@@ -16475,8 +16628,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isTypeVar)(specializedSrcType) &&
                 specializedSrcType.details.isSynthesizedSelf &&
                 specializedSrcType.details.boundType) {
-                specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(specializedSrcType.details.boundType, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(specializedSrcType)), 
-                /* unknownIfNotFound */ true);
+                specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(specializedSrcType.details.boundType, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(specializedSrcType)), { unknownIfNotFound: true });
             }
         }
         if (!assignType(specializedSrcType, specializedDestType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcTypeVarContext, destTypeVarContext, flags, recursionCount)) {
@@ -16506,6 +16658,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (destDetails.argsIndex === undefined) {
             return;
         }
+        // If the *args parameter isn't an unpacked TypeVarTuple or tuple,
+        // we have nothing to do.
+        if (!(0, types_1.isUnpacked)(destDetails.params[destDetails.argsIndex].type)) {
+            return;
+        }
         // If the source doesn't have enough positional parameters, we have nothing to do.
         if (srcDetails.params.length < destDetails.argsIndex) {
             return;
@@ -16739,9 +16896,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // The converse situation is OK.
         if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
             srcParamDetails.argsIndex === undefined &&
+            srcType.details.paramSpec === undefined &&
             destParamDetails.argsIndex !== undefined &&
-            !destParamDetails.hasUnpackedVariadicTypeVar &&
-            !targetIncludesParamSpec) {
+            !destParamDetails.hasUnpackedVariadicTypeVar) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.argsParamMissing().format({
                 paramName: (_h = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _h !== void 0 ? _h : '',
             }));
@@ -17161,9 +17318,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Verify that the positional param count matches exactly or that the override
         // adds only params that preserve the original signature.
         let foundParamCountMismatch = false;
-        if (overrideParamDetails.positionParamCount < baseParamDetails.positionParamCount &&
-            overrideParamDetails.argsIndex === undefined) {
-            foundParamCountMismatch = true;
+        if (overrideParamDetails.positionParamCount < baseParamDetails.positionParamCount) {
+            if (overrideParamDetails.argsIndex === undefined) {
+                foundParamCountMismatch = true;
+            }
+            else {
+                const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
+                for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
+                    if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
+                        localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
+                            index: i + 1,
+                            baseType: printType(baseParamDetails.params[i].type),
+                            overrideType: printType(overrideArgsType),
+                        });
+                        canOverride = false;
+                    }
+                }
+            }
         }
         else if (overrideParamDetails.positionParamCount > baseParamDetails.positionParamCount) {
             // Verify that all of the override parameters that extend the
@@ -17682,6 +17853,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,
+        getTypeResult,
         getCachedType,
         getTypeOfExpression,
         getTypeOfAnnotation,