@zzzen/pyright-internal 1.2.0-dev.20230521 → 1.2.0-dev.20230528

package/dist/analyzer/typeEvaluator.js

@@ -858,6 +858,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function stripLiteralValue(type) {
+        var _a, _b, _c;
+        // Handle the not-uncommon case where the type is a union that consists
+        // only of literal str or literal int values.
+        if ((0, types_1.isUnion)(type) && type.subtypes.length > 0) {
+            if (((_a = type.literalStrMap) === null || _a === void 0 ? void 0 : _a.size) === type.subtypes.length ||
+                ((_b = type.literalIntMap) === null || _b === void 0 ? void 0 : _b.size) === type.subtypes.length ||
+                ((_c = type.literalEnumMap) === null || _c === void 0 ? void 0 : _c.size) === type.subtypes.length) {
+                return stripLiteralValue(type.subtypes[0]);
+            }
+        }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isClass)(subtype)) {
                 if (subtype.literalValue !== undefined) {
@@ -880,9 +890,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfParameterAnnotation(paramTypeNode, paramCategory) {
         return getTypeOfAnnotation(paramTypeNode, {
             associateTypeVarsWithScope: true,
-            allowTypeVarTuple: paramCategory === 1 /* VarArgList */,
-            allowUnpackedTypedDict: paramCategory === 2 /* VarArgDictionary */,
-            allowUnpackedTuple: paramCategory === 1 /* VarArgList */,
+            allowTypeVarTuple: paramCategory === 1 /* ArgsList */,
+            allowUnpackedTypedDict: paramCategory === 2 /* KwargsDict */,
+            allowUnpackedTuple: paramCategory === 1 /* ArgsList */,
         });
     }
     function getTypeOfAnnotation(node, options) {
@@ -3338,7 +3348,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (baseType.details.isParamSpec) {
                     if (memberName === 'args') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 1 /* VarArgList */) {
+                        if (!paramNode || paramNode.category !== 1 /* ArgsList */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecArgsUsage(), node);
                             return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
@@ -3346,7 +3356,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (memberName === 'kwargs') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 2 /* VarArgDictionary */) {
+                        if (!paramNode || paramNode.category !== 2 /* KwargsDict */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecKwargsUsage(), node);
                             return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
@@ -6487,6 +6497,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
+            (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
             const param = paramInfo.param;
             if (param.name && param.category === 0 /* Simple */) {
                 paramMap.set(param.name, {
@@ -6537,8 +6548,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (argList.some((arg) => arg.argumentCategory === 1 /* UnpackedList */)) {
             argList.forEach((arg) => {
                 if (arg.name) {
-                    const keywordParamIndex = paramDetails.params.findIndex((paramInfo) => paramInfo.param.name === arg.name.value &&
-                        paramInfo.param.category === 0 /* Simple */);
+                    const keywordParamIndex = paramDetails.params.findIndex((paramInfo) => {
+                        (0, debug_1.assert)(paramInfo, 'paramInfo entry is undefined fork kwargs check');
+                        return (paramInfo.param.name === arg.name.value &&
+                            paramInfo.param.category === 0 /* Simple */);
+                    });
                     // Is this a parameter that can be interpreted as either a keyword or a positional?
                     // If so, we'll treat it as a keyword parameter in this case because it's being
                     // targeted by a keyword argument.
@@ -6616,7 +6630,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, debug_1.assert)(paramDetails.params[paramIndex], 'paramIndex params entry is undefined');
             const paramType = paramDetails.params[paramIndex].type;
             const paramName = paramDetails.params[paramIndex].param.name;
-            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* ArgsList */ &&
                 (0, types_1.isVariadicTypeVar)(paramType);
             if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
@@ -6677,7 +6691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType =
                         (_e = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                         /* isAsync */ false, argList[argIndex].valueExpression)) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
-                    if (paramDetails.params[paramIndex].param.category !== 1 /* VarArgList */) {
+                    if (paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
                 }
@@ -6722,16 +6736,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     paramMap.has(paramName)) {
                     paramMap.get(paramName).argsReceived++;
                 }
-                if (advanceToNextArg ||
-                    paramDetails.params[paramIndex].param.category === 1 /* VarArgList */) {
+                if (advanceToNextArg || paramDetails.params[paramIndex].param.category === 1 /* ArgsList */) {
                     argIndex++;
                 }
                 if (isVariadicTypeVarFullyMatched ||
-                    paramDetails.params[paramIndex].param.category !== 1 /* VarArgList */) {
+                    paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                     paramIndex++;
                 }
             }
-            else if (paramDetails.params[paramIndex].param.category === 1 /* VarArgList */) {
+            else if (paramDetails.params[paramIndex].param.category === 1 /* ArgsList */) {
                 trySetActive(argList[argIndex], paramDetails.params[paramIndex].param);
                 if (paramSpecArgList) {
                     paramSpecArgList.push(argList[argIndex]);
@@ -6747,7 +6760,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveParamType = paramType.tupleTypeArguments[0].type;
                     }
                     paramCategory = (0, types_1.isVariadicTypeVar)(effectiveParamType)
-                        ? 1 /* VarArgList */
+                        ? 1 /* ArgsList */
                         : 0 /* Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
@@ -6804,7 +6817,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let skippedArgsParam = false;
         if (positionalOnlyLimitIndex >= 0 &&
             paramIndex < positionalOnlyLimitIndex &&
-            paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+            paramIndex < paramDetails.params.length &&
+            paramDetails.params[paramIndex].param.category === 1 /* ArgsList */ &&
             !(0, types_1.isParamSpec)(paramDetails.params[paramIndex].param.type)) {
             paramIndex++;
             skippedArgsParam = true;
@@ -6825,7 +6839,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // because it's permitted to pass zero arguments to *args.
                 argsRemainingCount--;
             }
-            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* VarArgList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
+            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* ArgsList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
             if (firstArgsParam >= paramIndex && firstArgsParam < positionalOnlyLimitIndex) {
                 // If there is another args parameter beyond the current param index,
                 // reduce the count by one because it's permitted to pass zero arguments
@@ -6887,7 +6901,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else if (paramDetails.kwargsIndex !== undefined) {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
-                                    paramCategory: 2 /* VarArgDictionary */,
+                                    paramCategory: 2 /* KwargsDict */,
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: {
@@ -6925,7 +6939,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         unpackedDictionaryArgType = types_1.AnyType.create();
                         if (typeResult.type.details.paramSpec) {
                             validateArgTypeParams.push({
-                                paramCategory: 2 /* VarArgDictionary */,
+                                paramCategory: 2 /* KwargsDict */,
                                 paramType: typeResult.type.details.paramSpec,
                                 requiresTypeVarMatching: false,
                                 argument: argList[argIndex],
@@ -7010,7 +7024,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
-                                    paramCategory: 2 /* VarArgDictionary */,
+                                    paramCategory: 2 /* KwargsDict */,
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
@@ -7054,7 +7068,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'args') {
                                 validateArgTypeParams.push({
-                                    paramCategory: 1 /* VarArgList */,
+                                    paramCategory: 1 /* ArgsList */,
                                     paramType: typeResult.type.details.paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
@@ -7157,6 +7171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // already been matched, see if the type of that *args parameter is a variadic
             // type variable. If so, we'll preprocess those arguments and combine them
             // into a tuple.
+            (0, debug_1.assert)(paramDetails.argsIndex === undefined || paramDetails.argsIndex < paramDetails.params.length, 'paramDetails.argsIndex params entry is invalid');
             if (paramDetails.argsIndex !== undefined &&
                 paramDetails.argsIndex >= 0 &&
                 paramDetails.params[paramDetails.argsIndex].param.hasDeclaredType &&
@@ -7203,7 +7218,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             /* isUnpackedTuple */ true));
                         }
                         const combinedArg = {
-                            paramCategory: 1 /* VarArgList */,
+                            paramCategory: 1 /* ArgsList */,
                             paramType,
                             requiresTypeVarMatching: true,
                             argument: {
@@ -7253,6 +7268,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         var _a;
         const type = matchResults.overload;
+        // Can we safely ignore the inference context (either because it's not provided
+        // or will have no effect)? If so, we can eliminate a bunch of extra work.
         if (!inferenceContext ||
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
@@ -7282,6 +7299,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
         }
         if (effectiveExpectedType) {
+            const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
             // Prepopulate the typeVarContext based on the specialized expected type if the
             // callee has a declared return type. This will allow us to more closely match
             // the expected type if possible.
@@ -7301,7 +7319,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
                     const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
+                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes);
                     const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                     /* typeArguments */ undefined, 
                     /* isTypeArgumentExplicit */ false);
@@ -7317,6 +7335,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                 }
             }
+            effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes);
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
@@ -7413,17 +7432,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
-                        // If we skipped a overload arg during the first pass,
-                        // add another pass to ensure that we handle all of the
-                        // type variables.
+                        // If we skipped an overload arg or a bare type var during the first pass,
+                        // add another pass to ensure that we handle all of the type variables.
                         if (i === 0 && (argResult.skippedOverloadArg || argResult.skippedBareTypeVarExpectedType)) {
                             passCount++;
                         }
                     });
                 });
             }
-            // Lock the type var map so it cannot be modified and revalidate the
-            // arguments in a second pass.
+            // Lock the type var map so it cannot be modified when revalidating
+            // the arguments in a second pass.
             typeVarContext.lock();
         }
         let sawParamSpecArgs = false;
@@ -7511,21 +7529,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId) {
             eliminateUnsolvedInUnions = false;
         }
-        // In general, we want to replace in-scope TypeVars with Unknown
-        // if they were not solved. However, if the return type is a
-        // Callable, we'll leave the TypeVars unsolved because
-        // 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 unknownIfNotFound = !(0, types_1.isFunction)(returnType);
-        // We'll also leave TypeVars unsolved if the call is a recursive
+        // We'll leave TypeVars unsolved if the call is a recursive
         // call to a generic function.
-        const typeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        if (typeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope))) {
-            unknownIfNotFound = false;
-        }
+        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
+            unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
             useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
             applyInScopePlaceholders: true,
@@ -7578,6 +7587,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             overloadsUsedForCall: argumentErrors ? [] : [type],
         };
     }
+    // In general, all in-scope type variables left in a return type should be
+    // replaced with Unknown. However, if the return type is a callable that uses
+    // type vars that are found nowhere within the function's input parameters,
+    // we'll treat these as though they're scoped to the callable and leave them
+    // unsolved.
+    function getUnknownExemptTypeVarsForReturnType(functionType, returnType) {
+        if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
+            const returnTypeScopeId = returnType.details.typeVarScopeId;
+            // If one or more type vars found within the return type are scoped to
+            // the functionType but don't appear anywhere else within the functionType's
+            // input parameters, rescope them to the return type callable so they are
+            // not replaced with Unknown.
+            if (returnTypeScopeId && functionType.details.typeVarScopeId) {
+                let typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
+                // Remove any type variables that appear in the function's input parameters.
+                functionType.details.parameters.forEach((param, index) => {
+                    if (param.hasDeclaredType) {
+                        const typeVarsInInputParam = (0, typeUtils_1.getTypeVarArgumentsRecursive)(param.type);
+                        typeVarsInReturnType = typeVarsInReturnType.filter((returnTypeVar) => !typeVarsInInputParam.some((inputTypeVar) => (0, types_1.isTypeSame)(returnTypeVar, inputTypeVar)));
+                    }
+                });
+                return typeVarsInReturnType;
+            }
+        }
+        return [];
+    }
     function adjustCallableReturnType(returnType) {
         // 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
@@ -7657,8 +7692,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (positionalIndexLimit < 0) {
             positionalIndexLimit = paramSpecParams.length;
         }
-        const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* VarArgList */);
-        const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* VarArgDictionary */);
+        const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* ArgsList */);
+        const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* KwargsDict */);
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         let sawUnpackedListArgument = false;
         let sawUnpackedDictArgument = false;
@@ -7718,7 +7753,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (arg.argumentCategory === 1 /* UnpackedList */) {
                 sawUnpackedListArgument = true;
                 // See if there is an *args parameter.
-                const argsParam = paramSpecParams.find((param) => param.category === 1 /* VarArgList */ && param.name);
+                const argsParam = paramSpecParams.find((param) => param.category === 1 /* ArgsList */ && param.name);
                 if (argsParam && paramMap.has(argsParam.name)) {
                     // TODO - validate args type
                     paramMap.delete(argsParam.name);
@@ -7728,7 +7763,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 sawUnpackedDictArgument = true;
                 (0, debug_1.assert)(arg.argumentCategory === 2 /* UnpackedDictionary */);
                 // See if there is an *kwargs parameter.
-                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* VarArgDictionary */);
+                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* KwargsDict */);
                 if (kwargsParam && paramMap.has(kwargsParam.name)) {
                     // TODO - validate kwargs type
                     paramMap.delete(kwargsParam.name);
@@ -7856,7 +7891,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
-        if (argParam.paramCategory === 2 /* VarArgDictionary */ && (0, types_1.isTypeVar)(argParam.paramType)) {
+        if (argParam.paramCategory === 2 /* KwargsDict */ && (0, types_1.isTypeVar)(argParam.paramType)) {
             argType = stripLiteralValue(argType);
         }
         // If there's a constraint filter, apply it to top-level type variables
@@ -9230,28 +9265,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
+        // Handle the case where the expected type contains a ParamSpec.
+        if (expectedFunctionType === null || expectedFunctionType === void 0 ? void 0 : expectedFunctionType.details.paramSpec) {
+            functionType.details.paramSpec = expectedFunctionType.details.paramSpec;
+        }
         const expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
-        const inferLambdaReturnType = () => {
+        // We need to set allowCacheRetention to false because we don't want to
+        // cache the type of the lambda return expression because it depends on
+        // the parameter types that we set above, and the speculative type cache
+        // doesn't know about that context.
+        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
             /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
-        };
-        // We need to set allowCacheRetention to false because we don't want to
-        // cache the type of the lambda return expression because it depends on
-        // the parameter types that we set above, and the speculative type cache
-        // doesn't know about that context.
-        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
-            inferLambdaReturnType();
-        }, 
-        /* allowCacheRetention */ false);
+        }, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
         return { type: functionType, isIncomplete };
@@ -9260,13 +9295,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         let isIncomplete = false;
         let typeErrors = false;
+        // If any of the "for" clauses are marked async or any of the "if" clauses
+        // or the final expression contain an "await" operator anywhere within
+        // the expression, it is treated as an async generator.
         let isAsync = node.forIfNodes.some((comp) => {
             return ((comp.nodeType === 33 /* ListComprehensionFor */ && comp.isAsync) ||
                 (comp.nodeType === 34 /* ListComprehensionIf */ &&
-                    comp.testExpression.nodeType === 6 /* Await */));
+                    ParseTreeUtils.containsAwaitNode(comp.testExpression)));
         });
         let type = types_1.UnknownType.create();
-        if (node.expression.nodeType === 6 /* Await */) {
+        if (ParseTreeUtils.containsAwaitNode(node.expression)) {
             isAsync = true;
         }
         let expectedElementType;
@@ -9506,12 +9544,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const paramName = `__p${index.toString()}`;
                     if ((0, types_1.isVariadicTypeVar)(entryType)) {
                         validateVariadicTypeVarIsUnpacked(entryType, entry.node);
-                        paramCategory = 1 /* VarArgList */;
+                        paramCategory = 1 /* ArgsList */;
                         noteSawUnpacked(entry);
                     }
                     else if (validateTypeArg(entry, { allowUnpackedTuples: true })) {
                         if ((0, types_1.isUnpackedClass)(entryType)) {
-                            paramCategory = 1 /* VarArgList */;
+                            paramCategory = 1 /* ArgsList */;
                             noteSawUnpacked(entry);
                         }
                     }
@@ -11896,17 +11934,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             param.defaultValue.constType === 26 /* None */ &&
             !(0, typeUtils_1.isOptionalType)(type) &&
             !AnalyzerNodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
-            type = (0, types_1.combineTypes)([type, types_1.NoneType.createInstance()]);
-        }
-        else if ((0, types_1.isTypeVar)(type) && param.defaultValue && type.scopeType === 1 /* Function */) {
-            // Handle the case where a default argument type is provided when the
-            // parameter is annotated with a "raw" function-scoped type variable, as in:
-            //   "def foo(value: T = 3)"
-            // In this case, we need to include the default value type in a union.
-            const defaultArgType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(type)).type;
-            if (!(0, types_1.isAny)(defaultArgType)) {
-                type = (0, types_1.combineTypes)([type, defaultArgType]);
-            }
+            return (0, types_1.combineTypes)([type, types_1.NoneType.createInstance()]);
         }
         return type;
     }
@@ -11990,7 +12018,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 0 /* Simple */: {
                 return type;
             }
-            case 1 /* VarArgList */: {
+            case 1 /* ArgsList */: {
                 if ((0, types_1.isTypeVar)(type) && type.paramSpecAccess) {
                     return type;
                 }
@@ -12003,7 +12031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return types_1.UnknownType.create();
             }
-            case 2 /* VarArgDictionary */: {
+            case 2 /* KwargsDict */: {
                 // Leave a ParamSpec alone.
                 if ((0, types_1.isTypeVar)(type) && type.paramSpecAccess) {
                     return type;
@@ -12961,9 +12989,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             getTypeOfAnnotation(annotationNode, {
                 isVariableAnnotation: ((_a = annotationNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* TypeAnnotation */,
                 allowUnpackedTuple: annotationParent.nodeType === 41 /* Parameter */ &&
-                    annotationParent.category === 1 /* VarArgList */,
+                    annotationParent.category === 1 /* ArgsList */,
                 allowUnpackedTypedDict: annotationParent.nodeType === 41 /* Parameter */ &&
-                    annotationParent.category === 2 /* VarArgDictionary */,
+                    annotationParent.category === 2 /* KwargsDict */,
             });
             return;
         }
@@ -13879,11 +13907,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // types, under the assumption that we're performing speculative evaluations.
     // If speculativeNode is undefined, speculative mode is not used. This is
     // useful in cases where we conditionally want to use speculative mode.
-    function useSpeculativeMode(speculativeNode, callback, allowCacheRetention = true) {
+    function useSpeculativeMode(speculativeNode, callback, dependentType) {
         if (!speculativeNode) {
             return callback();
         }
-        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, allowCacheRetention);
+        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, dependentType);
         try {
             const result = callback();
             speculativeTypeTracker.leaveSpeculativeContext();
@@ -16638,7 +16666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const srcPositionalsToPack = srcDetails.params.slice(destDetails.argsIndex, srcLastToPackIndex - suffixLength);
         const srcTupleTypes = [];
         srcPositionalsToPack.forEach((entry) => {
-            if (entry.param.category === 1 /* VarArgList */) {
+            if (entry.param.category === 1 /* ArgsList */) {
                 if ((0, types_1.isUnpackedVariadicTypeVar)(entry.type)) {
                     srcTupleTypes.push({ type: entry.type, isUnbounded: false });
                 }
@@ -16670,7 +16698,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ...srcDetails.params.slice(0, destDetails.argsIndex),
                 {
                     param: {
-                        category: 1 /* VarArgList */,
+                        category: 1 /* ArgsList */,
                         name: '_arg_combined',
                         isNameSynthesized: true,
                         hasDeclaredType: true,
@@ -16682,9 +16710,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 },
                 ...srcDetails.params.slice(destDetails.argsIndex + srcPositionalsToPack.length, srcDetails.params.length),
             ];
-            const argsIndex = srcDetails.params.findIndex((param) => param.param.category === 1 /* VarArgList */);
+            const argsIndex = srcDetails.params.findIndex((param) => param.param.category === 1 /* ArgsList */);
             srcDetails.argsIndex = argsIndex >= 0 ? argsIndex : undefined;
-            const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* VarArgDictionary */);
+            const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* KwargsDict */);
             srcDetails.kwargsIndex = kwargsIndex >= 0 ? kwargsIndex : undefined;
             const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.source === parameterUtils_1.ParameterSource.KeywordOnly);
             srcDetails.firstKeywordOnlyIndex = firstKeywordOnlyIndex >= 0 ? firstKeywordOnlyIndex : undefined;
@@ -16722,8 +16750,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (destParamName && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(destParamName) && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(srcParamName)) {
                 const isDestPositionalOnly = destParam.source === parameterUtils_1.ParameterSource.PositionOnly;
                 if (!isDestPositionalOnly &&
-                    destParam.param.category !== 1 /* VarArgList */ &&
-                    srcParam.param.category !== 1 /* VarArgList */ &&
+                    destParam.param.category !== 1 /* ArgsList */ &&
+                    srcParam.param.category !== 1 /* ArgsList */ &&
                     destParamName !== srcParamName) {
                     diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamName().format({
                         srcName: srcParamName,
@@ -17019,7 +17047,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             matchedParamCount++;
                         }
                     }
-                    else if (!p.name && p.category === 0 /* Simple */ && remainingParams.length === 0) {
+                    else if ((0, types_1.isPositionOnlySeparator)(p) && remainingParams.length === 0) {
                         // Don't bother pushing a position-only separator if it
                         // is the first remaining param.
                     }
@@ -17348,7 +17376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     baseParam.category === 0 /* Simple */ &&
                     baseParam.name !== overrideParam.name) {
                     if (overrideParam.category === 0 /* Simple */) {
-                        if (enforceParamNames) {
+                        if (enforceParamNames && !baseParam.isNameSynthesized) {
                             if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                                     index: i + 1,
@@ -17368,11 +17396,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
-                        index: i + 1,
-                        baseName: baseParam.name || '*',
-                    }));
-                    canOverride = false;
+                    if (!baseParam.isNameSynthesized) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                            index: i + 1,
+                            baseName: baseParam.name || '*',
+                        }));
+                        canOverride = false;
+                    }
                 }
                 else {
                     const baseParamType = baseParamDetails.params[i].type;
@@ -17483,6 +17513,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 canOverride = false;
             }
         }
+        // Verify that one or the other method doesn't contain a ParamSpec.
+        if (baseMethod.details.paramSpec && !overrideMethod.details.paramSpec) {
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
+            canOverride = false;
+        }
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);