@zzzen/pyright-internal 1.2.0-dev.20260823 → 1.2.0-dev.20260906

package/dist/analyzer/typeEvaluator.js

@@ -2260,9 +2260,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode)?.type;
                 if (!iterReturnType) {
-                    // There was no __iter__. See if we can fall back to
-                    // the __getitem__ method instead.
+                    // There was no callable __iter__. The legacy sequence protocol
+                    // falls back to __getitem__, but CPython does that only when
+                    // __iter__ is missing. An explicit `__iter__ = None` (or any
+                    // non-callable __iter__) makes the object not iterable.
+                    let hasExplicitIterMember = false;
                     if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
+                        hasExplicitIterMember = !!(0, typeUtils_1.lookUpObjectMember)(subtype, iterMethodName, 16 /* MemberAccessFlags.SkipInstanceMembers */ |
+                            512 /* MemberAccessFlags.SkipAttributeAccessOverride */ |
+                            4 /* MemberAccessFlags.SkipObjectBaseClass */);
+                    }
+                    if (!isAsync && (0, types_1.isClassInstance)(subtype) && !hasExplicitIterMember) {
                         const getItemReturnType = getTypeOfMagicMethodCall(subtype, '__getitem__', [
                             {
                                 type: prefetched?.intClass && (0, types_1.isInstantiableClass)(prefetched.intClass)
@@ -8167,7 +8175,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (expandedCallType.shared.fullName === 'builtins.sentinel' ||
                 expandedCallType.shared.fullName === 'typing_extensions.sentinel' ||
                 expandedCallType.shared.fullName === 'typing_extensions.Sentinel') {
-                return { returnType: (0, sentinel_1.createSentinelType)(evaluatorInterface, errorNode, argList, nodeInfo) };
+                return {
+                    returnType: (0, sentinel_1.createSentinelType)(evaluatorInterface, errorNode, argList, expandedCallType, nodeInfo),
+                };
             }
             if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeNotIntantiable().format({ type: className }), errorNode);
@@ -8233,6 +8243,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const overloadsUsedForCall = constructorResult.overloadsUsedForCall;
         const argumentErrors = constructorResult.argumentErrors;
         const isTypeIncomplete = constructorResult.isTypeIncomplete;
+        const usesBuiltInTypeNew = overloadsUsedForCall?.some((overload) => types_1.FunctionType.isBuiltIn(overload, 'builtins.type.__new__'));
         let returnType = constructorResult.returnType;
         // If the expandedCallType originated from a TypeVar, convert
         // the constructed type back to the TypeVar. For example, if
@@ -8264,10 +8275,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', nodeInfo.getFileInfo(errorNode).fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
-            newClassType.shared.baseClasses.push(getBuiltInType(errorNode, 'object'));
+            if (usesBuiltInTypeNew && argList.length >= 2) {
+                const baseTupleType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
+                if ((0, types_1.isClassInstance)(baseTupleType)) {
+                    const baseClasses = getBaseClassesFromTypeCall(baseTupleType);
+                    if (baseClasses) {
+                        newClassType.shared.baseClasses.push(...baseClasses);
+                    }
+                }
+            }
+            if (newClassType.shared.baseClasses.length === 0) {
+                newClassType.shared.baseClasses.push(getBuiltInType(errorNode, 'object'));
+            }
             newClassType.shared.effectiveMetaclass = expandedCallType;
             newClassType.shared.declaration = returnType.shared.declaration;
-            (0, typeUtils_1.computeMroLinearization)(newClassType);
+            if (!(0, typeUtils_1.computeMroLinearization)(newClassType)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), errorNode);
+            }
             returnType = newClassType;
         }
         return { returnType, overloadsUsedForCall, argumentErrors, isTypeIncomplete };
@@ -10435,6 +10459,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return classType;
     }
+    function getBaseClassesFromTypeCall(baseTupleType) {
+        if (!(0, typeUtils_1.isTupleClass)(baseTupleType) || baseTupleType.priv.tupleTypeArgs === undefined) {
+            return undefined;
+        }
+        return baseTupleType.priv.tupleTypeArgs.map((typeArg) => {
+            const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
+            return (0, typeUtils_1.isEffectivelyInstantiable)(specializedType) ? specializedType : types_1.UnknownType.create();
+        });
+    }
     // Implements the semantics of the multi-parameter variant of the "type" call.
     function createClassFromMetaclass(errorNode, argList, metaclass) {
         const fileInfo = nodeInfo.getFileInfo(errorNode);
@@ -10443,21 +10476,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         const className = arg0Type.priv.literalValue || '_';
-        const arg1Type = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
-        // TODO - properly handle case where tuple of base classes is provided.
-        if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.priv.tupleTypeArgs === undefined) {
+        const baseTupleType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
+        if (!(0, types_1.isClassInstance)(baseTupleType)) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 4194304 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), metaclass, arg1Type.shared.effectiveMetaclass);
-        arg1Type.priv.tupleTypeArgs.forEach((typeArg) => {
-            const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
-            if ((0, typeUtils_1.isEffectivelyInstantiable)(specializedType)) {
-                classType.shared.baseClasses.push(specializedType);
-            }
-            else {
-                classType.shared.baseClasses.push(types_1.UnknownType.create());
-            }
-        });
+        const baseClasses = getBaseClassesFromTypeCall(baseTupleType);
+        if (!baseClasses) {
+            return undefined;
+        }
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 4194304 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), metaclass, baseTupleType.shared.effectiveMetaclass);
+        classType.shared.baseClasses.push(...baseClasses);
         if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), errorNode);
         }
@@ -20055,6 +20083,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.kind !== parameterUtils_1.ParamKind.Positional || p.param.category !== 0 /* ParamCategory.Simple */ || !!p.defaultType));
         }
     }
+    // Determines whether the source's variadic **kwargs keyword parameter
+    // is assignable to the keyword form of a destination positional-or-keyword
+    // parameter.
+    function assignNamedParam(destDetails, srcDetails, paramIndex, diag, constraints, flags, recursionCount) {
+        const destParam = destDetails.params[paramIndex];
+        if (srcDetails.kwargsIndex === undefined) {
+            diag?.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
+                name: destParam.param.name ?? '',
+            }));
+            return false;
+        }
+        else if (!assignParam(destParam.type, srcDetails.params[srcDetails.kwargsIndex].type, paramIndex, diag?.createAddendum(), constraints, flags, recursionCount)) {
+            return (flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0;
+        }
+        else {
+            return true;
+        }
+    }
     function assignFunction(destType, srcType, diag, constraints, flags, recursionCount) {
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipReturnTypeCheck */) === 0;
@@ -20166,14 +20212,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (destParam.kind !== parameterUtils_1.ParamKind.Positional &&
                 destParam.kind !== parameterUtils_1.ParamKind.ExpandedArgs &&
                 srcParam.kind === parameterUtils_1.ParamKind.Positional &&
-                srcParamDetails.kwargsIndex === undefined &&
                 !srcParamDetails.params.some((p) => p.kind === parameterUtils_1.ParamKind.Keyword &&
                     p.param.category === 0 /* ParamCategory.Simple */ &&
                     p.param.name === destParam.param.name)) {
-                diag?.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
-                    name: destParam.param.name ?? '',
-                }));
-                canAssign = false;
+                if (!assignNamedParam(destParamDetails, srcParamDetails, paramIndex, diag, constraints, flags, recursionCount)) {
+                    canAssign = false;
+                }
             }
         }
         if (!types_1.FunctionType.isGradualCallableForm(destType) &&
@@ -20259,13 +20303,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             canAssign = false;
                         }
                         const destParamKind = destParamDetails.params[paramIndex].kind;
-                        if (destParamKind !== parameterUtils_1.ParamKind.Positional &&
-                            destParamKind !== parameterUtils_1.ParamKind.ExpandedArgs &&
-                            srcParamDetails.kwargsIndex === undefined) {
-                            diag?.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
-                                name: destParamDetails.params[paramIndex].param.name ?? '',
-                            }));
-                            canAssign = false;
+                        if (destParamKind !== parameterUtils_1.ParamKind.Positional && destParamKind !== parameterUtils_1.ParamKind.ExpandedArgs) {
+                            if (!assignNamedParam(destParamDetails, srcParamDetails, paramIndex, diag, constraints, flags, recursionCount)) {
+                                canAssign = false;
+                            }
                         }
                     }
                 }
@@ -20359,7 +20400,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         srcParamInfo.kind === parameterUtils_1.ParamKind.Positional) {
                         return;
                     }
-                    const destParamInfo = destParamMap.get(srcParamInfo.param.name);
+                    const destParamInfo = destParamMap.get(srcParamInfo.param.name) ??
+                        destParamDetails.params.find((paramInfo) => paramInfo.param.name === srcParamInfo.param.name &&
+                            paramInfo.kind === parameterUtils_1.ParamKind.Standard &&
+                            paramInfo.param.category === 0 /* ParamCategory.Simple */);
                     const paramDiag = diag?.createAddendum();
                     const srcParamType = srcParamInfo.type;
                     if (!destParamInfo) {
@@ -20390,6 +20434,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                         return;
                     }
+                    // A keyword-only source parameter was matched to a positional-or-keyword
+                    // dest parameter. The dest parameter can be called positionally, but a
+                    // keyword-only source parameter with no default would be left unsatisfied.
+                    if (destParamInfo.kind === parameterUtils_1.ParamKind.Standard &&
+                        srcParamInfo.kind === parameterUtils_1.ParamKind.Keyword &&
+                        !srcParamInfo.defaultType) {
+                        if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
+                            paramDiag?.addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
+                                name: srcParamInfo.param.name,
+                            }));
+                            canAssign = false;
+                            return;
+                        }
+                    }
                     // If we're performing a partial overload match and both the source
                     // and dest parameters provide defaults, assume that there could
                     // be a match.
@@ -20412,7 +20470,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 destType: printType(srcParamType),
                             }));
                         }
-                        canAssign = false;
+                        if (destParamInfo.kind !== parameterUtils_1.ParamKind.Standard ||
+                            (flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
+                            canAssign = false;
+                        }
                     }
                     if (destParamInfo.defaultType && !srcParamInfo.defaultType) {
                         diag?.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({