@zzzen/pyright-internal 1.2.0-dev.20260614 → 1.2.0-dev.20260628

package/dist/analyzer/typeEvaluator.js

@@ -30,13 +30,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maxCodeComplexity = void 0;
 exports.createTypeEvaluator = createTypeEvaluator;
@@ -554,9 +564,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const anySpecialForm = types_1.AnyType.createSpecialForm();
                 if ((0, types_1.isAny)(anySpecialForm)) {
                     types_1.TypeBase.setSpecialForm(anySpecialForm, anyClass);
-                    if (isTypeFormSupported(node)) {
-                        types_1.TypeBase.setTypeForm(anySpecialForm, (0, typeUtils_1.convertToInstance)(anySpecialForm));
-                    }
+                    types_1.TypeBase.setTypeForm(anySpecialForm, (0, typeUtils_1.convertToInstance)(anySpecialForm));
                 }
             }
         }
@@ -685,7 +693,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // reported them when analyzing the contents of the string.
                     expectingInstantiable = false;
                 }
-                typeResult = getTypeOfStringList(node, flags);
+                typeResult = getTypeOfStringList(node, flags, inferenceContext);
                 break;
             }
             case 40 /* ParseNodeType.Number */: {
@@ -956,7 +964,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfStringList(node, flags) {
+    function getTypeOfStringList(node, flags, inferenceContext) {
         let typeResult;
         if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 && (flags & 1073741824 /* EvalFlags.TypeFormArg */) === 0) {
             return getTypeOfStringListAsType(node, flags);
@@ -1021,9 +1029,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isIncomplete,
             };
         }
-        if (node.d.strings.length !== 1 ||
-            node.d.strings[0].nodeType !== 49 /* ParseNodeType.String */ ||
-            !isTypeFormSupported(node)) {
+        if (node.d.strings.length !== 1 || node.d.strings[0].nodeType !== 49 /* ParseNodeType.String */) {
+            return typeResult;
+        }
+        // Only attempt to interpret the string as a TypeForm forward reference when
+        // there's a signal that a TypeForm value is wanted in this context. Doing it
+        // unconditionally can trigger expensive (and recursion-prone) type lookups
+        // for plain string literals in non-type contexts.
+        const wantsTypeForm = (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ||
+            (inferenceContext !== undefined && expectedTypeWantsTypeForm(inferenceContext.expectedType));
+        if (!wantsTypeForm) {
             return typeResult;
         }
         // For performance reasons, do not attempt to treat the string literal
@@ -1705,15 +1720,35 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let signatures = [];
         function addOneFunctionToSignature(type) {
             let callResult;
+            const constraints = new constraintTracker_1.ConstraintTracker();
             useSpeculativeMode(callNode, () => {
-                callResult = validateArgs(exprNode, argList, { type }, 
-                /* constraints */ undefined, 
+                callResult = validateArgs(exprNode, argList, { type }, constraints, 
                 /* skipUnknownArgCheck */ true, 
                 /* inferenceContext */ undefined);
             });
+            const specializedType = solveAndApplyConstraints(type, constraints);
+            const finalType = (0, types_1.isFunction)(specializedType) ? specializedType : type;
+            const hasActiveArg = argList.some((arg) => arg.active);
+            // If the type was specialized (e.g. ParamSpec expansion), the activeParam
+            // from the original validateArgs refers to parameters in the unspecialized
+            // type and won't match the specialized type's parameters. Re-run validateArgs
+            // against the specialized type to get the correct activeParam mapping.
+            let activeParam = callResult?.activeParam;
+            if (hasActiveArg && finalType !== type) {
+                let specializedActiveParam;
+                useSpeculativeMode(callNode, () => {
+                    const specializedResult = validateArgs(exprNode, argList, { type: finalType }, new constraintTracker_1.ConstraintTracker(), 
+                    /* skipUnknownArgCheck */ true, 
+                    /* inferenceContext */ undefined);
+                    specializedActiveParam = specializedResult?.activeParam;
+                });
+                if (specializedActiveParam) {
+                    activeParam = specializedActiveParam;
+                }
+            }
             signatures.push({
-                type: expandTypedKwargs(type),
-                activeParam: callResult?.activeParam,
+                type: expandTypedKwargs(finalType),
+                activeParam,
             });
         }
         function addFunctionToSignature(type) {
@@ -1796,11 +1831,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             types_1.FunctionType.addKeywordOnlyParamSeparator(newFunction);
         }
         tdEntries.forEach((tdEntry, name) => {
-            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, tdEntry.valueType, types_1.FunctionParamFlags.TypeDeclared, name, tdEntry.isRequired ? undefined : tdEntry.valueType));
+            // A TypedDict entry type may carry the TypedDict's own type parameters (e.g. an unpacked
+            // generic TypedDict `**kwargs: Unpack[TD[int]]`), so specialize each entry against the
+            // (possibly generic) TypedDict instance. Specializing an already-concrete type is a
+            // no-op, so this is safe for non-generic TypedDicts.
+            const specializedValueType = (0, typeUtils_1.partiallySpecializeType)(tdEntry.valueType, kwargsType, 
+            /* typeClassType */ undefined);
+            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, specializedValueType, types_1.FunctionParamFlags.TypeDeclared, name, tdEntry.isRequired ? undefined : specializedValueType));
         });
         const extraItemsType = kwargsType.shared.typedDictEntries?.extraItems?.valueType;
         if (extraItemsType && !(0, types_1.isNever)(extraItemsType)) {
-            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(2 /* ParamCategory.KwargsDict */, extraItemsType, types_1.FunctionParamFlags.TypeDeclared, 'kwargs'));
+            // Specialized for the same reason as the per-entry types above. This PEP 728
+            // `extra_items` branch uses the identical mechanism and is intentionally not
+            // separately tested.
+            const specializedExtraItemsType = (0, typeUtils_1.partiallySpecializeType)(extraItemsType, kwargsType, 
+            /* typeClassType */ undefined);
+            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(2 /* ParamCategory.KwargsDict */, specializedExtraItemsType, types_1.FunctionParamFlags.TypeDeclared, 'kwargs'));
         }
         return newFunction;
     }
@@ -3359,9 +3405,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return { type, isIncomplete };
     }
     function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
-        if (!isTypeFormSupported(node)) {
-            return type;
-        }
         const isValid = isSymbolValidTypeExpression(type, includesVarDecl);
         // If the type already has type information associated with it, don't replace.
         if (type.props?.typeForm) {
@@ -5267,9 +5310,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ...aliasInfo,
             typeArgs: aliasTypeArgs,
         });
-        if (isTypeFormSupported(node)) {
-            type = types_1.TypeBase.cloneWithTypeForm(type, reportedError ? undefined : (0, typeUtils_1.convertToInstance)(type));
-        }
+        type = types_1.TypeBase.cloneWithTypeForm(type, reportedError ? undefined : (0, typeUtils_1.convertToInstance)(type));
         if (baseType.props?.typeAliasInfo) {
             return { type, node };
         }
@@ -6153,7 +6194,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { type: types_1.UnknownType.create() };
         }
         const typeFormResult = getTypeOfArgExpectingType(convertNodeToArg(node.d.args[0]), {
-            typeFormArg: isTypeFormSupported(node),
+            typeFormArg: true,
             noNonTypeSpecialForms: true,
             typeExpression: true,
         });
@@ -9548,7 +9589,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (node.d.constType === 15 /* KeywordType.False */) {
                 return false;
             }
-            else if (node.d.constType === 33 /* KeywordType.True */) {
+            else if (node.d.constType === 34 /* KeywordType.True */) {
                 return true;
             }
         }
@@ -9669,25 +9710,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfConstant(node, flags) {
         let type;
-        if (node.d.constType === 26 /* KeywordType.None */) {
+        if (node.d.constType === 27 /* KeywordType.None */) {
             if (prefetched?.noneTypeClass) {
                 type =
                     (flags & 128 /* EvalFlags.InstantiableType */) !== 0
                         ? prefetched.noneTypeClass
                         : (0, typeUtils_1.convertToInstance)(prefetched.noneTypeClass);
-                if (isTypeFormSupported(node)) {
-                    type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
-                }
+                type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
             }
         }
-        else if (node.d.constType === 33 /* KeywordType.True */ ||
+        else if (node.d.constType === 34 /* KeywordType.True */ ||
             node.d.constType === 15 /* KeywordType.False */ ||
             node.d.constType === 9 /* KeywordType.Debug */) {
             type = getBuiltInObject(node, 'bool');
             // For True and False, we can create truthy and falsy
             // versions of 'bool'.
             if (type && (0, types_1.isClassInstance)(type)) {
-                if (node.d.constType === 33 /* KeywordType.True */) {
+                if (node.d.constType === 34 /* KeywordType.True */) {
                     type = types_1.ClassType.cloneWithLiteral(type, /* value */ true);
                 }
                 else if (node.d.constType === 15 /* KeywordType.False */) {
@@ -10987,7 +11026,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (paramSpec) {
             types_1.FunctionType.addParamSpecVariadics(functionType, (0, typeUtils_1.convertToInstance)(paramSpec));
         }
-        if (isTypeFormSupported(errorNode) && isValidTypeForm) {
+        if (isValidTypeForm) {
             functionType = types_1.TypeBase.cloneWithTypeForm(functionType, (0, typeUtils_1.convertToInstance)(functionType));
         }
         return functionType;
@@ -11092,13 +11131,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if (itemExpr.nodeType === 14 /* ParseNodeType.Constant */) {
-                if (itemExpr.d.constType === 33 /* KeywordType.True */) {
+                if (itemExpr.d.constType === 34 /* KeywordType.True */) {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'bool', true);
                 }
                 else if (itemExpr.d.constType === 15 /* KeywordType.False */) {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'bool', false);
                 }
-                else if (itemExpr.d.constType === 26 /* KeywordType.None */) {
+                else if (itemExpr.d.constType === 27 /* KeywordType.None */) {
                     type = prefetched?.noneTypeClass ?? types_1.UnknownType.create();
                 }
             }
@@ -11152,7 +11191,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnion)(result) && prefetched?.unionTypeClass && (0, types_1.isInstantiableClass)(prefetched.unionTypeClass)) {
             result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(prefetched.unionTypeClass));
         }
-        if (isTypeFormSupported(node) && isValidTypeForm) {
+        if (isValidTypeForm) {
             result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
         }
         return result;
@@ -11198,9 +11237,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
         });
         let resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
-        if (isTypeFormSupported(errorNode)) {
-            resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
-        }
+        resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
         return resultType;
     }
     // Creates a "TypeGuard" and "TypeIs" type.
@@ -11222,9 +11259,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
         });
         let resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
-        if (isTypeFormSupported(errorNode)) {
-            resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
-        }
+        resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
         return resultType;
     }
     function createSelfType(classType, errorNode, typeArgs, flags) {
@@ -11657,7 +11692,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 unionType = types_1.TypeBase.cloneWithTypeForm(unionType, undefined);
             }
         }
-        else if (isTypeFormSupported(errorNode)) {
+        else {
             const typeFormType = (0, types_1.combineTypes)(types.map((t) => t.props.typeForm));
             unionType = types_1.TypeBase.cloneWithTypeForm(unionType, typeFormType);
         }
@@ -11923,16 +11958,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (assignedName === 'LiteralString') {
                 specialType.shared.baseClasses.push(prefetched?.strClass ?? types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
-                if (isTypeFormSupported(node)) {
-                    specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
-                }
+                specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
             }
             // Handle 'Never' and 'NoReturn' specially.
             if (assignedName === 'Never' || assignedName === 'NoReturn') {
                 specialType = types_1.TypeBase.cloneAsSpecialForm(assignedName === 'Never' ? types_1.NeverType.createNever() : types_1.NeverType.createNoReturn(), specialType);
-                if (isTypeFormSupported(node)) {
-                    specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
-                }
+                specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
             }
             writeTypeCache(node, { type: specialType }, 0 /* EvalFlags.None */);
             return specialType;
@@ -13625,7 +13656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // of the specified type and 'None'). Skip this step if the type is already
         // optional to avoid losing alias names when combining the types.
         if (param.d.defaultValue?.nodeType === 14 /* ParseNodeType.Constant */ &&
-            param.d.defaultValue.d.constType === 26 /* KeywordType.None */ &&
+            param.d.defaultValue.d.constType === 27 /* KeywordType.None */ &&
             !(0, typeUtils_1.isOptionalType)(type) &&
             !AnalyzerNodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
             return (0, types_1.combineTypes)([type, getNoneType()]);
@@ -14736,6 +14767,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 evaluateTypesForAssignmentStatement(parent);
                 return;
             }
+            case 5 /* ParseNodeType.AugmentedAssignment */: {
+                evaluateTypesForAugmentedAssignment(parent);
+                return;
+            }
         }
         if (nodeToEvaluate.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
             evaluateTypesForTypeAnnotationNode(nodeToEvaluate);
@@ -15010,9 +15045,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     let resultType = aliasedName === 'Never' ? types_1.NeverType.createNever() : types_1.NeverType.createNoReturn();
                     resultType = types_1.TypeBase.cloneAsSpecialForm(resultType, classType);
-                    if (isTypeFormSupported(errorNode)) {
-                        resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
-                    }
+                    resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
                     return { type: resultType };
                 }
                 case 'Optional': {
@@ -15025,9 +15058,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
-                    if (isTypeFormSupported(errorNode)) {
-                        typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
-                    }
+                    typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
                     return { type: typeType };
                 }
                 case 'ClassVar': {
@@ -15136,9 +15167,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
-                    if (isTypeFormSupported(errorNode)) {
-                        typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
-                    }
+                    typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
                     return { type: typeType };
                 }
             }
@@ -15149,9 +15178,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* paramLimit */ undefined, 
                 /* allowParamSpec */ undefined, 
                 /* isSpecialForm */ false);
-                if (isTypeFormSupported(errorNode)) {
-                    specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, (0, typeUtils_1.convertToInstance)(specializedClass));
-                }
+                specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, (0, typeUtils_1.convertToInstance)(specializedClass));
                 return { type: specializedClass };
             }
         }
@@ -15343,9 +15370,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeArgTypes = typeArgs.map((t) => (0, typeUtils_1.convertToInstance)(t.type));
         }
         let specializedClass = types_1.ClassType.specialize(classType, typeArgTypes, typeArgs !== undefined);
-        if (isTypeFormSupported(errorNode)) {
-            specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, isValidTypeForm ? (0, typeUtils_1.convertToInstance)(specializedClass) : undefined);
-        }
+        specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, isValidTypeForm ? (0, typeUtils_1.convertToInstance)(specializedClass) : undefined);
         return { type: specializedClass };
     }
     // PEP 612 says that if the class has only one type parameter consisting
@@ -18256,6 +18281,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         return isAssignable;
     }
+    function expectedTypeWantsTypeForm(expectedType) {
+        return (0, typeUtils_1.someSubtypes)(expectedType, (subtype) => (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'TypeForm'));
+    }
     // If the expected type is an explicit TypeForm type, see if the source
     // type has an implicit TypeForm type that can be assigned to it. If so,
     // convert to an explicit TypeForm type.
@@ -19174,9 +19202,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     continue;
                 }
                 const nonDefaultSrcParamCount = srcParamDetails.params.filter((p) => !!p.param.name && !p.defaultType && p.param.category === 0 /* ParamCategory.Simple */).length;
-                diag?.createAddendum().addMessage(localize_1.LocAddendum.functionTooFewParams().format({
-                    expected: nonDefaultSrcParamCount,
-                    received: destPositionalCount,
+                diag?.createAddendum().addMessage(localize_1.LocAddendum.functionTooManyParams().format({
+                    expected: destPositionalCount,
+                    received: nonDefaultSrcParamCount,
                 }));
                 canAssign = false;
                 break;
@@ -19228,9 +19256,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 if (srcPositionalCount < adjDestPositionalCount) {
-                    diag?.addMessage(localize_1.LocAddendum.functionTooManyParams().format({
-                        expected: srcPositionalCount,
-                        received: destPositionalCount,
+                    diag?.addMessage(localize_1.LocAddendum.functionTooFewParams().format({
+                        expected: adjDestPositionalCount,
+                        received: srcPositionalCount,
                     }));
                     canAssign = false;
                 }
@@ -19780,15 +19808,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if (overrideParamDetails.positionParamCount > baseParamDetails.positionParamCount) {
-                // Verify that all of the override parameters that extend the
-                // signature are either *args, **kwargs or parameters with
-                // default values.
-                for (let i = baseParamDetails.positionParamCount; i < overrideParamDetails.positionParamCount; i++) {
-                    const overrideParam = overrideParamDetails.params[i].param;
-                    if (overrideParam.category === 0 /* ParamCategory.Simple */ &&
-                        overrideParam.name &&
-                        !overrideParamDetails.params[i].defaultType) {
-                        foundParamCountMismatch = true;
+                const isCallableAttrOverriddenByInstanceMethod = baseParamDetails.positionParamCount === 0 &&
+                    overrideParamDetails.positionParamCount === 1 &&
+                    types_1.FunctionType.isInstanceMethod(overrideMethod) &&
+                    !types_1.FunctionType.isStaticMethod(baseMethod) &&
+                    !types_1.FunctionType.isClassMethod(baseMethod);
+                if (!isCallableAttrOverriddenByInstanceMethod) {
+                    // Verify that all of the override parameters that extend the
+                    // signature are either *args, **kwargs or parameters with
+                    // default values.
+                    for (let i = baseParamDetails.positionParamCount; i < overrideParamDetails.positionParamCount; i++) {
+                        const overrideParam = overrideParamDetails.params[i].param;
+                        if (overrideParam.category === 0 /* ParamCategory.Simple */ &&
+                            overrideParam.name &&
+                            !overrideParamDetails.params[i].defaultType) {
+                            foundParamCountMismatch = true;
+                        }
                     }
                 }
             }
@@ -20311,7 +20346,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 49 /* ParseNodeType.String */:
                 return allowStrLiteral;
             case 14 /* ParseNodeType.Constant */:
-                return node.d.constType === 26 /* KeywordType.None */;
+                return node.d.constType === 27 /* KeywordType.None */;
             case 7 /* ParseNodeType.BinaryOperation */:
                 return (node.d.operator === 6 /* OperatorType.BitwiseOr */ &&
                     isLegalTypeAliasExpressionForm(node.d.leftExpr, /* allowStrLiteral */ true) &&
@@ -20396,11 +20431,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { sourceType: simpleSrcType, destType: simpleDestType };
     }
-    function isTypeFormSupported(node) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        // For now, enable only if enableExperimentalFeatures is true.
-        return fileInfo.diagnosticRuleSet.enableExperimentalFeatures;
-    }
     function printType(type, options) {
         let flags = evaluatorOptions.printTypeFlags;
         if (options?.expandTypeAlias) {
@@ -20424,6 +20454,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options?.useFullyQualifiedNames) {
             flags |= 4096 /* TypePrinter.PrintTypeFlags.UseFullyQualifiedNames */;
         }
+        if (options?.disablePep604) {
+            flags &= ~8 /* TypePrinter.PrintTypeFlags.PEP604 */;
+        }
         return TypePrinter.printType(type, flags, getEffectiveReturnType);
     }
     // Calls back into the parser to parse the contents of a string literal.