@zzzen/pyright-internal 1.2.0-dev.20260719 → 1.2.0-dev.20260726

package/dist/analyzer/typeEvaluator.js

@@ -1864,6 +1864,39 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return false;
     }
+    // Given a member symbol and the context in which it was accessed, computes
+    // the declared type of the member (applying descriptor setter types, partial
+    // specialization, and function binding as appropriate). Returns undefined if
+    // the symbol has no declared type.
+    function resolveDeclaredMemberType(symbol, classOrObjectBase, memberAccessClass, useDescriptorSetterType, bindFunction, selfType) {
+        let declaredType = getDeclaredTypeOfSymbol(symbol)?.type;
+        if (!declaredType) {
+            return undefined;
+        }
+        // If it's a descriptor, we need to get the setter type.
+        if (useDescriptorSetterType && (0, types_1.isClassInstance)(declaredType)) {
+            const setter = getBoundMagicMethod(declaredType, '__set__');
+            if (setter && (0, types_1.isFunction)(setter) && setter.shared.parameters.length >= 2) {
+                declaredType = types_1.FunctionType.getParamType(setter, 1);
+                if ((0, types_1.isAnyOrUnknown)(declaredType)) {
+                    return undefined;
+                }
+            }
+        }
+        if (classOrObjectBase) {
+            if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
+                declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType(), selfType);
+            }
+            if ((0, types_1.isFunctionOrOverloaded)(declaredType)) {
+                if (bindFunction) {
+                    declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType, 
+                    /* memberClass */ undefined, 
+                    /* treatConstructorAsClassMethod */ undefined, selfType);
+                }
+            }
+        }
+        return declaredType;
+    }
     // Determines whether the specified expression is a symbol with a declared type.
     function getDeclaredTypeForExpression(expression, usage) {
         let symbol;
@@ -1903,10 +1936,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const baseType = getTypeOfExpression(expression.d.leftExpr, 2 /* EvalFlags.MemberAccessBaseDefaults */).type;
                 const baseTypeConcrete = makeTopLevelTypeVarsConcrete(baseType);
                 const memberName = expression.d.member.d.value;
-                // Normally, baseTypeConcrete will not be a composite type (a union),
-                // but this can occur. In this case, it's not clear how to handle this
-                // correctly. For now, we'll just loop through the subtypes and
-                // use one of them. We'll sort the subtypes for determinism.
+                if ((0, types_1.isTypeVar)(baseType)) {
+                    selfType = baseType;
+                }
+                // Normally, baseType will not be a composite type (a union), but
+                // this can occur. In this case, we compute the declared type of the
+                // member for each subtype. If the subtypes declare the member with
+                // the same generic class but different (invariant) type arguments
+                // (e.g. "list[int]" vs. "list[str]"), there is no single declared
+                // type that can serve as the expected type for bidirectional
+                // inference of an assigned value. Committing to one subtype's
+                // declared type produces a false positive when assigning a value
+                // (such as an empty container) that is compatible with every
+                // subtype, so in that case we return undefined and let the value be
+                // evaluated without an expected type. We sort the subtypes for
+                // determinism.
+                //
+                // This is deliberately limited to the "same class, differing type
+                // arguments" case. When the subtypes declare the member with
+                // unrelated types, we retain the previous behavior (use one
+                // subtype's declared type) so that genuine assignment errors are
+                // still reported at the same location and downstream inference is
+                // unchanged.
+                //
+                // This handling is further limited to cases where the declared base
+                // type is itself a union. We intentionally don't apply it when the
+                // base is a type variable that merely concretizes to a union.
+                const isUnionBase = (0, types_1.isUnion)(baseType);
+                let firstMemberDeclaredType;
+                let sawMemberDeclaredType = false;
+                let hasDivergentMemberDeclaredTypes = false;
+                let divergesOnlyByTypeArgs = true;
                 (0, typeUtils_1.doForEachSubtype)(baseTypeConcrete, (baseSubtype) => {
                     if ((0, types_1.isClassInstance)(baseSubtype)) {
                         const classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseSubtype, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
@@ -1937,10 +1997,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         useDescriptorSetterType = false;
                         bindFunction = false;
                     }
+                    // If the base is a union, verify that the subtypes agree on a
+                    // single declared type for the member.
+                    if (isUnionBase) {
+                        const subtypeDeclaredType = symbol
+                            ? resolveDeclaredMemberType(symbol, classOrObjectBase, memberAccessClass, useDescriptorSetterType, bindFunction, selfType)
+                            : undefined;
+                        if (subtypeDeclaredType) {
+                            if (!sawMemberDeclaredType) {
+                                firstMemberDeclaredType = subtypeDeclaredType;
+                                sawMemberDeclaredType = true;
+                            }
+                            else if (!firstMemberDeclaredType ||
+                                !(0, types_1.isTypeSame)(firstMemberDeclaredType, subtypeDeclaredType)) {
+                                hasDivergentMemberDeclaredTypes = true;
+                                // The false positive we're addressing is specific
+                                // to invariant type arguments of the same generic
+                                // class. If the divergent types aren't instances of
+                                // the same generic class, don't treat this as an
+                                // ambiguous declared type.
+                                if (!firstMemberDeclaredType ||
+                                    !(0, types_1.isClassInstance)(firstMemberDeclaredType) ||
+                                    !(0, types_1.isClassInstance)(subtypeDeclaredType) ||
+                                    !types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstantiable(firstMemberDeclaredType), types_1.ClassType.cloneAsInstantiable(subtypeDeclaredType))) {
+                                    divergesOnlyByTypeArgs = false;
+                                }
+                            }
+                        }
+                    }
                 }, 
                 /* sortSubtypes */ true);
-                if ((0, types_1.isTypeVar)(baseType)) {
-                    selfType = baseType;
+                if (hasDivergentMemberDeclaredTypes && divergesOnlyByTypeArgs) {
+                    return undefined;
                 }
                 break;
             }
@@ -2009,32 +2097,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (symbol) {
-            let declaredType = getDeclaredTypeOfSymbol(symbol)?.type;
-            if (declaredType) {
-                // If it's a descriptor, we need to get the setter type.
-                if (useDescriptorSetterType && (0, types_1.isClassInstance)(declaredType)) {
-                    const setter = getBoundMagicMethod(declaredType, '__set__');
-                    if (setter && (0, types_1.isFunction)(setter) && setter.shared.parameters.length >= 2) {
-                        declaredType = types_1.FunctionType.getParamType(setter, 1);
-                        if ((0, types_1.isAnyOrUnknown)(declaredType)) {
-                            return undefined;
-                        }
-                    }
-                }
-                if (classOrObjectBase) {
-                    if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
-                        declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType(), selfType);
-                    }
-                    if ((0, types_1.isFunctionOrOverloaded)(declaredType)) {
-                        if (bindFunction) {
-                            declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType, 
-                            /* memberClass */ undefined, 
-                            /* treatConstructorAsClassMethod */ undefined, selfType);
-                        }
-                    }
-                }
-                return declaredType;
-            }
+            return resolveDeclaredMemberType(symbol, classOrObjectBase, memberAccessClass, useDescriptorSetterType, bindFunction, selfType);
         }
         return undefined;
     }