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

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;
@@ -292,25 +290,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             cachedType = typeCache.get(node.id);
         }
-        return cachedType !== undefined;
+        return cachedType !== undefined && !cachedType.isIncomplete;
     }
-    function readTypeCache(node, flags) {
-        var _a, _b;
-        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);
         }
-        if (cachedType === undefined) {
+    }
+    function readTypeCache(node, flags) {
+        var _a, _b;
+        const cacheEntry = readTypeCacheEntry(node);
+        if (!cacheEntry || cacheEntry.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 +327,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        (0, debug_1.assert)(!(0, typeCache_1.isIncompleteType)(cachedType));
-        return cachedType;
+        return cacheEntry.type;
     }
     function writeTypeCache(node, type, flags, isIncomplete, expectedType, allowSpeculativeCaching = false) {
-        if (isIncomplete) {
-            if (incompleteTypeCache) {
-                incompleteTypeCache.set(node.id, type);
-            }
-            return;
-        }
         // 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, { type, isIncomplete, 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);
+                speculativeTypeTracker.addSpeculativeType(node, { type, isIncomplete }, expectedType);
             }
         }
     }
@@ -517,12 +505,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         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 { type: cachedTypeResult.type, isIncomplete: cachedTypeResult.isIncomplete };
             }
         }
         if (printExpressionTypes) {
@@ -2758,7 +2746,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 +2757,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 +2901,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 +3017,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({
@@ -3060,9 +3059,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 +3085,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 +3163,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 +3187,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 +3206,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 +3243,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 +3251,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 */ |
@@ -4205,12 +4225,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 +4270,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 +4311,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 +4344,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 +4406,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 +4426,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 +4451,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 +4518,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 +4976,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 +4989,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        return { type, expectedTypeDiagAddendum };
+        return { type, expectedTypeDiagAddendum, isIncomplete };
     }
     function getTypeOfTupleInferred(node) {
         const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
@@ -5949,7 +5976,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 +7363,17 @@ 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,
+            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)) {
@@ -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);
@@ -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;
     }
@@ -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) {
@@ -10741,6 +10786,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;
@@ -10778,7 +10824,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,
@@ -11096,6 +11142,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);
         }
@@ -11284,6 +11340,34 @@ 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) {
+            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;
@@ -11590,6 +11674,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 */);
@@ -11689,8 +11774,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 +11929,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);
@@ -11878,19 +11972,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) {
+        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.returnTypeAnnotation, {
-                associateTypeVarsWithScope: true,
-                disallowRecursiveTypeAlias: true,
-            });
-            functionType.details.declaredReturnType = returnType;
-        }
-        else if (node.functionAnnotationComment) {
-            // 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 +11997,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 +12016,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 */;
@@ -11963,6 +12063,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node, decoratedType, 0 /* None */, /* isIncomplete */ false);
         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'
@@ -13311,36 +13442,16 @@ 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 };
+        // If the type cache is already populated with a complete type,
+        // don't bother doing additional work.
+        let cacheEntry = readTypeCacheEntry(subnode);
+        if (cacheEntry && !cacheEntry.isIncomplete) {
+            return { type: cacheEntry.type };
         }
-        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;
+        callback();
+        cacheEntry = readTypeCacheEntry(subnode);
+        if (cacheEntry) {
+            return { type: cacheEntry.type, isIncomplete: cacheEntry.isIncomplete };
         }
         return undefined;
     }
@@ -13605,8 +13716,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 +13727,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 +13741,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 +13768,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) {
@@ -14198,65 +14320,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 +14365,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, typeVar, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node.name, typeVar, /* flags */ undefined, /* isIncomplete */ false);
+        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, 
@@ -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)) {
@@ -17161,9 +17313,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