@zzzen/pyright-internal 1.2.0-dev.20240407 → 1.2.0-dev.20240421

package/dist/analyzer/typeEvaluator.js

@@ -170,7 +170,7 @@ const printExpressionTypes = false;
 // complex. Otherwise we risk overflowing the stack or incurring extremely
 // long analysis times. This number has been tuned empirically.
 exports.maxCodeComplexity = 768;
-function createTypeEvaluator(importLookup, evaluatorOptions) {
+function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const symbolResolutionStack = [];
     const asymmetricAccessorAssignmentCache = new Set();
     const speculativeTypeTracker = new typeCacheUtils_1.SpeculativeTypeTracker();
@@ -890,12 +890,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult = getTypeOfExpression(node.typeAnnotation, updatedFlags);
             }
             else if (!node.typeAnnotation && node.strings.length === 1) {
-                // We didn't know at parse time that this string node was going
-                // to be evaluated as a forward-referenced type. We need
-                // to re-invoke the parser at this stage.
-                const expr = parseStringAsTypeAnnotation(node);
-                if (expr) {
-                    typeResult = getTypeOfExpression(expr, updatedFlags);
+                const tokenFlags = node.strings[0].token.flags;
+                if (tokenFlags & 32 /* StringTokenFlags.Bytes */) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationBytesString(), node);
+                    typeResult = { type: types_1.UnknownType.create() };
+                }
+                else if (tokenFlags & 8 /* StringTokenFlags.Raw */) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationRawString(), node);
+                    typeResult = { type: types_1.UnknownType.create() };
+                }
+                else if (tokenFlags & 64 /* StringTokenFlags.Format */) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationFormatString(), node);
+                    typeResult = { type: types_1.UnknownType.create() };
+                }
+                else {
+                    // We didn't know at parse time that this string node was going
+                    // to be evaluated as a forward-referenced type. We need
+                    // to re-invoke the parser at this stage.
+                    const expr = parseStringAsTypeAnnotation(node);
+                    if (expr) {
+                        typeResult = getTypeOfExpression(expr, updatedFlags);
+                    }
                 }
             }
             if (!typeResult) {
@@ -1430,6 +1445,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
+                narrowedTypeForSet: memberInfo.narrowedTypeForSet,
                 memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
                 typeErrors: memberInfo.isDescriptorError,
             };
@@ -2258,6 +2274,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
+        var _a;
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
         // Handle member accesses (e.g. self.x or cls.y).
@@ -2305,7 +2322,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setAsymmetricDescriptorAssignment(target);
         }
         const resultToCache = {
-            type,
+            type: (_a = setTypeResult.narrowedTypeForSet) !== null && _a !== void 0 ? _a : type,
             isIncomplete: isTypeIncomplete,
             memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
         };
@@ -2933,7 +2950,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeParamSymbol) {
             symbol = typeParamSymbol;
             (0, debug_1.assert)(symbol.getDeclarations().length === 1);
-            const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
             (0, debug_1.assert)((decl === null || decl === void 0 ? void 0 : decl.type) === 3 /* DeclarationType.TypeParameter */);
             type = getTypeOfTypeParameter(decl.node);
             setSymbolAccessed(fileInfo, symbol, node);
@@ -3533,6 +3550,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let diag = new diagnostic_1.DiagnosticAddendum();
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         let type;
+        let narrowedTypeForSet;
+        let typeErrors = false;
         let isIncomplete = !!baseTypeResult.isIncomplete;
         let isAsymmetricAccessor;
         const isRequired = false;
@@ -3617,15 +3636,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
                     /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
                 }
-                if (typeResult && !typeResult.typeErrors) {
-                    type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
-                    /* skipSelfCondition */ true);
-                    if (typeResult.isIncomplete) {
-                        isIncomplete = true;
+                if (typeResult) {
+                    if (!typeResult.typeErrors) {
+                        type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
+                        /* skipSelfCondition */ true);
+                    }
+                    else {
+                        typeErrors = true;
                     }
                     if (typeResult.isAsymmetricAccessor) {
                         isAsymmetricAccessor = true;
                     }
+                    if (typeResult.isIncomplete) {
+                        isIncomplete = true;
+                    }
+                    if (typeResult.narrowedTypeForSet) {
+                        narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(typeResult.narrowedTypeForSet, (0, typeUtils_1.getTypeCondition)(baseType), 
+                        /* skipSelfCondition */ true);
+                    }
                     if (typeResult.memberAccessDeprecationInfo) {
                         memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
                     }
@@ -3726,9 +3754,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (typeResult.isIncomplete) {
                         isIncomplete = true;
                     }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+                    if (typeResult.memberAccessDeprecationInfo) {
                         memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
                     }
+                    if (typeResult.typeErrors) {
+                        typeErrors = true;
+                    }
                     return typeResult.type;
                 });
                 break;
@@ -3795,7 +3826,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node.memberName);
         }
-        return { type, isIncomplete, isAsymmetricAccessor, isRequired, isNotRequired, memberAccessDeprecationInfo };
+        return {
+            type,
+            isIncomplete,
+            isAsymmetricAccessor,
+            narrowedTypeForSet,
+            isRequired,
+            isNotRequired,
+            memberAccessDeprecationInfo,
+            typeErrors,
+        };
     }
     function getTypeOfClassMemberName(errorNode, classType, memberName, usage, diag, flags, selfType, recursionCount = 0) {
         var _a, _b, _c;
@@ -3831,6 +3871,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let type;
         let isTypeIncomplete = false;
+        let narrowedTypeForSet;
         if (memberInfo.symbol.isInitVar()) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberIsInitVar().format({ name: memberName }));
             return undefined;
@@ -3985,6 +4026,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return resultType;
         });
         if (!isDescriptorError && usage.method === 'set' && usage.setType) {
+            if (errorNode && memberInfo.symbol.hasTypedDeclarations()) {
+                // This is an assignment to a member with a declared type. Apply
+                // narrowing logic based on the assigned type. Skip this for
+                // descriptor-based accesses.
+                narrowedTypeForSet = isDescriptorApplied
+                    ? usage.setType.type
+                    : narrowTypeBasedOnAssignment(errorNode, type, usage.setType.type);
+            }
             // Verify that the assigned type is compatible.
             if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
                 if (!usage.setType.isIncomplete) {
@@ -3994,6 +4043,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         classType: printObjectTypeForClass(classType),
                     }));
                 }
+                // Do not narrow the type in this case. Assume the declared type.
+                narrowedTypeForSet = type;
                 isDescriptorError = true;
             }
             if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
@@ -4014,6 +4065,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isClassVar: memberInfo.isClassVar,
             classType: memberInfo.classType,
             isAsymmetricAccessor,
+            narrowedTypeForSet,
             memberAccessDeprecationInfo,
         };
     }
@@ -6644,7 +6696,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!symbol.isClassMember() && !symbol.isNamedTupleMemberMember()) {
             return undefined;
         }
-        const lastDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+        const lastDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
         if (!lastDecl) {
             return undefined;
         }
@@ -7010,7 +7062,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const paramDetails = (0, parameterUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -7057,8 +7109,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // function nested within another function that defines the param
                 // spec? We need to handle these two cases differently.
                 const paramSpecScopeId = varArgListParam.type.scopeId;
-                if (paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
-                    paramSpecScopeId === typeResult.type.details.constructorTypeVarScopeId) {
+                if ((_b = (0, typeUtils_1.getTypeVarScopeIds)(typeResult.type)) === null || _b === void 0 ? void 0 : _b.some((id) => id === paramSpecScopeId)) {
                     paramSpecArgList = [];
                     paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(varArgListParam.type, /* access */ undefined);
                 }
@@ -7069,9 +7120,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else if (typeResult.type.details.paramSpec) {
             const paramSpecScopeId = typeResult.type.details.paramSpec.scopeId;
-            if (typeResult.type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId ||
-                paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
-                paramSpecScopeId === typeResult.type.details.constructorTypeVarScopeId) {
+            if ((_c = (0, typeUtils_1.getTypeVarScopeIds)(typeResult.type)) === null || _c === void 0 ? void 0 : _c.some((id) => id === paramSpecScopeId)) {
                 hasParamSpecArgsKwargs = true;
                 paramSpecArgList = [];
                 paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(typeResult.type.details.paramSpec, 
@@ -7163,7 +7212,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
-                                }), (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode);
+                                }), (_d = argList[argIndex].valueExpression) !== null && _d !== void 0 ? _d : errorNode);
                         }
                         reportedArgError = true;
                     }
@@ -7196,7 +7245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
-                                }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                                }), (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode);
                         }
                         reportedArgError = true;
                     }
@@ -7238,9 +7287,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType = undefined;
                 }
                 else {
-                    listElementType = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
+                    listElementType = (_f = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                     /* isAsync */ false, errorNode, 
-                    /* emitNotIterableError */ false)) === null || _d === void 0 ? void 0 : _d.type;
+                    /* emitNotIterableError */ false)) === null || _f === void 0 ? void 0 : _f.type;
                     if (paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -7272,7 +7321,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType,
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: funcArg,
-                            errorNode: (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode,
+                            errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                             paramName,
                             isParamNameSynthesized: paramDetails.params[paramIndex].param.isNameSynthesized,
                             mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
@@ -7576,7 +7625,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
+                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
@@ -7592,7 +7641,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 paramType,
                                 requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                 argument: argList[argIndex],
-                                errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
+                                errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
                                 paramName: paramNameValue,
                             });
                             // Remember that this parameter has already received a value.
@@ -7642,7 +7691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
-                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                    errorNode: (_k = argList[argIndex].valueExpression) !== null && _k !== void 0 ? _k : errorNode,
                                 });
                             }
                         }
@@ -7954,12 +8003,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeVarContext.addSolveForScope(type.boundTypeVarScopeId);
                 }
             }
-            // Some typeshed stubs use specialized type annotations in the "self" parameter
-            // of an overloaded __init__ method to specify which specialized type should
-            // be constructed. Although this isn't part of the official Python spec, other
-            // type checkers appear to honor it.
+            // The type annotation for the "self" parameter in an __init__ method to
+            // can incluence the type being constructed.
             if (type.details.name === '__init__' &&
-                types_1.FunctionType.isOverloaded(type) &&
                 type.strippedFirstParamType &&
                 type.boundToType &&
                 (0, types_1.isClassInstance)(type.strippedFirstParamType) &&
@@ -8126,9 +8172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the function is returning a callable, don't eliminate unsolved
         // type vars within a union. There are legit uses for unsolved type vars
         // within a callable.
-        if ((0, types_1.isFunction)(returnType) ||
-            (0, types_1.isOverloadedFunction)(returnType) ||
-            type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId) {
+        if ((0, types_1.isFunction)(returnType) || (0, types_1.isOverloadedFunction)(returnType)) {
             eliminateUnsolvedInUnions = false;
         }
         // We'll leave TypeVars unsolved if the call is a recursive
@@ -8180,7 +8224,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useTypeIsSemantics));
             }
         }
-        specializedReturnType = adjustCallableReturnType(specializedReturnType, signatureTracker.getTrackedSignatures());
+        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        specializedReturnType = adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes, signatureTracker.getTrackedSignatures());
         if (specializedInitSelfType) {
             specializedInitSelfType = (0, typeUtils_1.applySolvedTypeVars)(specializedInitSelfType, typeVarContext);
         }
@@ -8223,23 +8268,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return [];
     }
     // If the return type includes a generic Callable type, set the type var
-    // scope to a wildcard to allow these type vars to be solved. This won't
-    // work with overloads or unions of callables. It's intended for a
-    // specific use case. We may need to make this more sophisticated in
-    // the future.
+    // scope to the scope of the function it was originally associated with
+    // to allow these type vars to be solved. This won't work with overloads
+    // or unions of callables. It's intended for a specific use case. We may
+    // need to make this more sophisticated in the future.
     // The trackedSignatures parameter supplies a list of function signatures
     // that were used for the function and the arguments passed to it. This is
     // important because the callable return value may be called again with
     // one of these signatures, so we may need to "uniquify" the type parameters
     // to avoid conflicts.
-    function adjustCallableReturnType(returnType, trackedSignatures) {
-        if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
-            const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
+    function adjustCallableReturnType(callableType, returnType, liveTypeVarScopes, trackedSignatures) {
+        if ((0, types_1.isFunction)(returnType) && !returnType.details.name && callableType.details.typeVarScopeId) {
+            // What type variables are referenced in the callable return type? Do not include any live type variables.
+            const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.scopeId === scopeId));
             // If there are no unsolved type variables, we're done. If there are
-            // unsolved type parameters, treat them as though they are rescoped
+            // unsolved type variables, treat them as though they are rescoped
             // to the callable.
             if (typeVarsInReturnType.length > 0) {
-                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId, typeVarsInReturnType, trackedSignatures);
+                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, callableType.details.typeVarScopeId, typeVarsInReturnType, trackedSignatures);
             }
         }
         return returnType;
@@ -8507,7 +8553,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isFunction)(concreteParamType) || (0, types_1.isOverloadedFunction)(concreteParamType)) {
                 if ((0, types_1.isInstantiableClass)(argType)) {
                     const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, argType);
-                    if (constructor && (0, types_1.isOverloadedFunction)(constructor)) {
+                    if (constructor) {
                         return {
                             isCompatible,
                             argType,
@@ -8754,7 +8800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function verifyTypeVarDefaultIsCompatible(typeVar, defaultValueNode) {
         (0, debug_1.assert)(typeVar.details.isDefaultExplicit);
-        const typeVarContext = new typeVarContext_1.TypeVarContext(types_1.WildcardTypeVarScopeId);
+        const typeVarContext = new typeVarContext_1.TypeVarContext(typeVar.scopeId);
         const concreteDefaultType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
             unknownIfNotFound: true,
         }));
@@ -8808,7 +8854,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramName === 'default') {
                     const expr = argList[i].valueExpression;
                     if (expr) {
-                        const defaultType = getTypeVarTupleDefaultType(expr);
+                        const defaultType = getTypeVarTupleDefaultType(expr, /* isPep695Syntax */ false);
                         if (defaultType) {
                             typeVar.details.defaultType = defaultType;
                             typeVar.details.isDefaultExplicit = true;
@@ -8831,10 +8877,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeVar;
     }
-    function getTypeVarTupleDefaultType(node) {
+    function getTypeVarTupleDefaultType(node, isPep695Syntax) {
         const argType = getTypeOfExpressionExpectingType(node, {
             allowUnpackedTuple: true,
             allowTypeVarsWithoutScopeId: true,
+            allowForwardReference: isPep695Syntax,
         }).type;
         const isUnpackedTuple = (0, types_1.isClass)(argType) && (0, typeUtils_1.isTupleClass)(argType) && argType.isUnpacked;
         const isUnpackedTypeVarTuple = (0, types_1.isUnpackedVariadicTypeVar)(argType);
@@ -8867,7 +8914,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramName === 'default') {
                     const expr = argList[i].valueExpression;
                     if (expr) {
-                        const defaultType = getParamSpecDefaultType(expr);
+                        const defaultType = getParamSpecDefaultType(expr, /* isPep695Syntax */ false);
                         if (defaultType) {
                             paramSpec.details.defaultType = defaultType;
                             paramSpec.details.isDefaultExplicit = true;
@@ -8891,7 +8938,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return paramSpec;
     }
-    function getParamSpecDefaultType(node) {
+    function getParamSpecDefaultType(node, isPep695Syntax) {
         const functionType = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (node.nodeType === 18 /* ParseNodeType.Ellipsis */) {
             types_1.FunctionType.addDefaultParameters(functionType);
@@ -8899,7 +8946,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (node.nodeType === 31 /* ParseNodeType.List */) {
             node.entries.forEach((paramExpr, index) => {
-                const typeResult = getTypeOfExpressionExpectingType(paramExpr, { allowTypeVarsWithoutScopeId: true });
+                const typeResult = getTypeOfExpressionExpectingType(paramExpr, {
+                    allowTypeVarsWithoutScopeId: true,
+                    allowForwardReference: isPep695Syntax,
+                });
                 types_1.FunctionType.addParameter(functionType, {
                     category: 0 /* ParameterCategory.Simple */,
                     name: `__p${index}`,
@@ -10454,6 +10504,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
                 }
+                itemExpr.strings.forEach((stringNode) => {
+                    if ((stringNode.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
+                    }
+                });
             }
             else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
                 if (!itemExpr.isImaginary && itemExpr.isInteger) {
@@ -13802,6 +13857,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         break;
                     }
                 }
+                else if (parent.nodeType === 75 /* ParseNodeType.TypeParameter */) {
+                    // If this is a bound or default expression in a type parameter list,
+                    // we need to evaluate it in the context of the type parameter.
+                    if (node === parent.boundExpression || node === parent.defaultExpression) {
+                        getTypeOfTypeParameter(parent);
+                        return;
+                    }
+                    break;
+                }
                 else {
                     break;
                 }
@@ -15103,6 +15167,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const constraints = node.boundExpression.expressions.map((constraint) => {
                     const constraintType = getTypeOfExpressionExpectingType(constraint, {
                         disallowProtocolAndTypedDict: true,
+                        allowForwardReference: true,
                     }).type;
                     if ((0, typeUtils_1.requiresSpecialization)(constraintType, {
                         ignorePseudoGeneric: true,
@@ -15122,6 +15187,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 const boundType = getTypeOfExpressionExpectingType(node.boundExpression, {
                     disallowProtocolAndTypedDict: true,
+                    allowForwardReference: true,
                 }).type;
                 if ((0, typeUtils_1.requiresSpecialization)(boundType, { ignorePseudoGeneric: true })) {
                     addError(localize_1.LocMessage.typeVarConstraintGeneric(), node.boundExpression);
@@ -15132,7 +15198,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
-            const defaultType = node.defaultExpression ? getParamSpecDefaultType(node.defaultExpression) : undefined;
+            const defaultType = node.defaultExpression
+                ? getParamSpecDefaultType(node.defaultExpression, /* isPep695Syntax */ true)
+                : undefined;
             if (defaultType) {
                 typeVar.details.defaultType = defaultType;
                 typeVar.details.isDefaultExplicit = true;
@@ -15142,7 +15210,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-            const defaultType = node.defaultExpression ? getTypeVarTupleDefaultType(node.defaultExpression) : undefined;
+            const defaultType = node.defaultExpression
+                ? getTypeVarTupleDefaultType(node.defaultExpression, /* isPep695Syntax */ true)
+                : undefined;
             if (defaultType) {
                 typeVar.details.defaultType = defaultType;
                 typeVar.details.isDefaultExplicit = true;
@@ -15153,7 +15223,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             const defaultType = node.defaultExpression
-                ? (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression).type)
+                ? (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression, { allowForwardReference: true }).type)
                 : undefined;
             if (defaultType) {
                 typeVar.details.defaultType = defaultType;
@@ -15782,14 +15852,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getFunctionEffectiveReturnType(type, args, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-            return adjustCallableReturnType(specializedReturnType, /* trackedSignatures */ undefined);
+            return adjustCallableReturnType(type, specializedReturnType, /* liveTypeVarScopes */ []);
         }
         if (inferTypeIfNeeded) {
             return getFunctionInferredReturnType(type, args);
         }
         return types_1.UnknownType.create();
     }
-    function getFunctionInferredReturnType(type, args) {
+    function _getFunctionInferredReturnType(type, args) {
         var _a;
         let returnType;
         let isIncomplete = false;
@@ -17148,6 +17218,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, concreteSrcType, (0, types_1.isTypeVar)(srcType) ? (0, typeUtils_1.convertToInstance)(srcType) : undefined, recursionCount);
                 if (constructor) {
                     concreteSrcType = constructor;
+                    // The constructor conversion may result in a union of the
+                    // __init__ and __new__ callables.
+                    if ((0, types_1.isUnion)(concreteSrcType)) {
+                        return assignType(destType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                    }
                 }
             }
             if ((0, types_1.isAnyOrUnknown)(concreteSrcType)) {
@@ -17357,12 +17432,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else if (remainingDestSubtypes.length === remainingSrcSubtypes.length) {
                     // If the number of remaining source subtypes is the same as the number
                     // of dest TypeVars, try to assign each source subtype to its own dest TypeVar.
-                    remainingDestSubtypes.forEach((destSubtype, index) => {
-                        const srcSubtype = remainingSrcSubtypes[index];
-                        if (!assignType(destSubtype, srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    const reorderedDestSubtypes = [...remainingDestSubtypes];
+                    for (let srcIndex = 0; srcIndex < remainingSrcSubtypes.length; srcIndex++) {
+                        let foundMatchForSrc = false;
+                        for (let destIndex = 0; destIndex < reorderedDestSubtypes.length; destIndex++) {
+                            if (assignType(reorderedDestSubtypes[destIndex], remainingSrcSubtypes[srcIndex], diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                                foundMatchForSrc = true;
+                                // Move the matched dest TypeVar to the end of the list so the other
+                                // dest TypeVars have a better chance of being assigned to.
+                                reorderedDestSubtypes.push(...reorderedDestSubtypes.splice(destIndex, 1));
+                                break;
+                            }
+                        }
+                        if (!foundMatchForSrc) {
                             canUseFastPath = false;
+                            break;
                         }
-                    });
+                    }
                     // We can avoid checking the source subtypes that have already been checked.
                     sortedSrcTypes = remainingSrcSubtypes;
                 }
@@ -18181,10 +18267,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
                     remainingFunction.details.constructorTypeVarScopeId =
                         effectiveSrcType.details.constructorTypeVarScopeId;
+                    remainingFunction.details.methodClass = effectiveSrcType.details.methodClass;
                     remainingParams.forEach((param) => {
                         types_1.FunctionType.addParameter(remainingFunction, param);
                     });
                     remainingFunction.details.paramSpec = srcParamSpec ? (0, typeUtils_1.convertToInstance)(srcParamSpec) : undefined;
+                    types_1.FunctionType.addHigherOrderTypeVarScopeIds(remainingFunction, effectiveSrcType.details.higherOrderTypeVarScopeIds);
                     if (!assignType(destParamSpec, remainingFunction, 
                     /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                         // If we couldn't assign the function to the ParamSpec, see if we can
@@ -18215,12 +18303,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, typeUtils_1.containsLiteralType)(srcType.details.declaredReturnType, /* includeTypeArgs */ true)) {
                     effectiveFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 }
-                if ((0, types_1.isNever)(srcReturnType)) {
-                    // We'll allow any function that returns NoReturn to match any
-                    // function return type, consistent with other type checkers.
-                    isReturnTypeCompatible = true;
-                }
-                else if (assignType(destReturnType, srcReturnType, returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, effectiveFlags, recursionCount)) {
+                if (assignType(destReturnType, srcReturnType, returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, effectiveFlags, recursionCount)) {
                     isReturnTypeCompatible = true;
                 }
                 else {
@@ -18893,11 +18976,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // If the memberType is an instance or class method, creates a new
     // version of the function that has the "self" or "cls" parameter bound
-    // to it. If treatConstructorAsClassMember is true, the function is
+    // to it. If treatConstructorAsClassMethod is true, the function is
     // treated like a class method even if it's not marked as such. That's
     // needed to special-case the __new__ magic method when it's invoked as
     // a constructor (as opposed to by name).
-    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember = false, selfType, diag, recursionCount = 0) {
+    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMethod = false, selfType, diag, recursionCount = 0) {
         return (0, typeUtils_1.mapSignatures)(memberType, (functionType) => {
             // If the caller specified no base type, always strip the
             // first parameter. This is used in cases like constructors.
@@ -18912,11 +18995,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const baseObj = (0, types_1.isClassInstance)(baseType)
                     ? baseType
                     : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
-                return partiallySpecializeFunctionForBoundClassOrObject(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, 
-                /* stripFirstParam */ (0, types_1.isClassInstance)(baseType));
+                let stripFirstParam = false;
+                if ((0, types_1.isClassInstance)(baseType)) {
+                    stripFirstParam = true;
+                }
+                else if (memberClass && (0, typeUtils_1.isInstantiableMetaclass)(memberClass)) {
+                    stripFirstParam = true;
+                }
+                return partiallySpecializeFunctionForBoundClassOrObject(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, stripFirstParam);
             }
             if (types_1.FunctionType.isClassMethod(functionType) ||
-                (treatConstructorAsClassMember && types_1.FunctionType.isConstructorMethod(functionType))) {
+                (treatConstructorAsClassMethod && types_1.FunctionType.isConstructorMethod(functionType))) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
                 const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
                 return partiallySpecializeFunctionForBoundClassOrObject(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, clsType !== null && clsType !== void 0 ? clsType : baseClass, 
@@ -19175,6 +19264,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
         });
     }
+    // Track these apis internal usages when logging is on. otherwise, it should be noop.
+    const getFunctionInferredReturnType = wrapWithLogger(_getFunctionInferredReturnType);
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,