@zzzen/pyright-internal 1.2.0-dev.20240324 → 1.2.0-dev.20240331

package/dist/analyzer/typeEvaluator.js

@@ -1421,13 +1421,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 subDiag = metaclassDiag;
             }
         }
-        if (memberInfo && !memberInfo.isDescriptorError) {
+        if (memberInfo) {
+            if (memberInfo.isDescriptorError && diag && subDiag) {
+                diag.addAddendum(subDiag);
+            }
             return {
                 type: memberInfo.type,
                 classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
                 memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
+                typeErrors: memberInfo.isDescriptorError,
             };
         }
         // If this is a type[Any] or type[Unknown], allow any other members.
@@ -1545,7 +1549,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let constructorType;
                         // Try to get the `__init__` method first because it typically has more
                         // type information than `__new__`.
-                        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 0 /* MemberAccessFlags.Default */);
+                        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 
+                        /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
                         if (initMethodResult && !initMethodResult.typeErrors) {
                             if ((0, types_1.isFunction)(initMethodResult.type) || (0, types_1.isOverloadedFunction)(initMethodResult.type)) {
                                 constructorType = initMethodResult.type;
@@ -1561,7 +1566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // the `object` class or accepts only default parameters(* args, ** kwargs),
                         // see if we can find a better signature from the `__new__` method.
                         if (!constructorType || isObjectInit || isDefaultParams) {
-                            const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 0 /* MemberAccessFlags.Default */);
+                            const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype);
                             if (newMethodResult && !newMethodResult.typeErrors) {
                                 if ((0, types_1.isFunction)(newMethodResult.type) &&
                                     newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
@@ -3611,18 +3616,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
                     /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
                 }
-                if (typeResult) {
+                if (typeResult && !typeResult.typeErrors) {
                     type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
                     /* skipSelfCondition */ true);
-                }
-                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
-                    isIncomplete = true;
-                }
-                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
-                    isAsymmetricAccessor = true;
-                }
-                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
-                    memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                    if (typeResult.isIncomplete) {
+                        isIncomplete = true;
+                    }
+                    if (typeResult.isAsymmetricAccessor) {
+                        isAsymmetricAccessor = true;
+                    }
+                    if (typeResult.memberAccessDeprecationInfo) {
+                        memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                    }
                 }
                 break;
             }
@@ -3701,7 +3706,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if ((0, typeUtils_1.isNoneInstance)(subtype) && noneType && (0, types_1.isClassInstance)(noneType)) {
                         const typeResult = getTypeOfBoundMember(node.memberName, noneType, memberName, usage, diag);
-                        if (typeResult) {
+                        if (typeResult && !typeResult.typeErrors) {
                             type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
                             if (typeResult.isIncomplete) {
                                 isIncomplete = true;
@@ -4015,7 +4020,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const methodTypeResult = getTypeOfBoundMember(errorNode, concreteMemberType, accessMethodName, 
         /* usage */ undefined, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
-        if (!methodTypeResult) {
+        if (!methodTypeResult || methodTypeResult.typeErrors) {
             // Provide special error messages for properties.
             if (types_1.ClassType.isPropertyClass(concreteMemberType)) {
                 if (usage.method !== 'get') {
@@ -6792,7 +6797,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const result = {
                     returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
                 };
-                const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 0 /* MemberAccessFlags.Default */);
+                const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 
+                /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
                 if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
                     validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
                     /* typeVarContext */ undefined, skipUnknownArgCheck, 
@@ -6895,15 +6901,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
         var _a;
+        const callDiag = new diagnostic_1.DiagnosticAddendum();
         const callMethodResult = getTypeOfBoundMember(errorNode, expandedCallType, '__call__', 
-        /* usage */ undefined, 
-        /* diag */ undefined, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, 
+        /* usage */ undefined, callDiag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, 
         /* selfType */ undefined, recursionCount);
         const callMethodType = callMethodResult === null || callMethodResult === void 0 ? void 0 : callMethodResult.type;
-        if (!callMethodType) {
+        if (!callMethodType || callMethodResult.typeErrors) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                 type: printType(expandedCallType),
-            }), errorNode);
+            }) + callDiag.getString(), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
         const callResult = validateCallArguments(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
@@ -9114,6 +9120,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             types_1.FunctionType.addDefaultParameters(newType);
             newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
+            newType.details.constructorTypeVarScopeId = classType.details.typeVarScopeId;
             classType.details.fields.set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
         }
         return classType;
@@ -9420,7 +9427,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
-            var _a;
+            var _a, _b, _c, _d;
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
@@ -9467,6 +9474,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncomplete = true;
                 }
                 if (forceStrictInference || index < maxEntriesToUseForInference) {
+                    // If an existing key has the same literal type, delete the previous
+                    // key since we're overwriting it here.
+                    if ((0, types_1.isClass)(keyType) && (0, typeUtils_1.isLiteralType)(keyType)) {
+                        const existingIndex = keyTypes.findIndex((kt) => (0, types_1.isTypeSame)(keyType, kt.type));
+                        if (existingIndex >= 0) {
+                            keyTypes.splice(existingIndex, 1);
+                            valueTypes.splice(existingIndex, 1);
+                        }
+                    }
                     keyTypes.push({ node: entryNode.keyExpression, type: keyType });
                     valueTypes.push({ node: entryNode.valueExpression, type: valueType });
                 }
@@ -9504,10 +9520,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* allowNarrowed */ true);
                         tdEntries.knownItems.forEach((entry, name) => {
                             if (entry.isRequired || entry.isProvided) {
-                                keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneWithLiteral(strObject, name) });
+                                keyTypes.push({
+                                    node: entryNode,
+                                    type: types_1.ClassType.cloneWithLiteral(strObject, name),
+                                });
                                 valueTypes.push({ node: entryNode, type: entry.valueType });
                             }
                         });
+                        if (!expectedTypedDictEntries) {
+                            keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneAsInstance(strObject) });
+                            valueTypes.push({
+                                node: entryNode,
+                                type: (_c = (_b = (_a = tdEntries.extraItems) === null || _a === void 0 ? void 0 : _a.valueType) !== null && _b !== void 0 ? _b : objectType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
+                            });
+                        }
                         addUnknown = false;
                     }
                 }
@@ -9541,7 +9567,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // The result should be a tuple.
                 if ((0, types_1.isClassInstance)(dictEntryType) && (0, typeUtils_1.isTupleClass)(dictEntryType)) {
-                    const typeArgs = (_a = dictEntryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.map((t) => t.type);
+                    const typeArgs = (_d = dictEntryType.tupleTypeArguments) === null || _d === void 0 ? void 0 : _d.map((t) => t.type);
                     if (typeArgs && typeArgs.length === 2) {
                         if (forceStrictInference || index < maxEntriesToUseForInference) {
                             keyTypes.push({ node: entryNode, type: typeArgs[0] });
@@ -12526,6 +12552,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else {
                     annotatedType = getTypeOfParameterAnnotation(paramTypeNode, param.category);
                 }
+                if (annotatedType) {
+                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(annotatedType), functionType.details.typeVarScopeId);
+                }
                 if ((0, types_1.isVariadicTypeVar)(annotatedType) && !annotatedType.isVariadicUnpacked) {
                     addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                         name1: annotatedType.details.name,
@@ -12631,7 +12660,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             };
             types_1.FunctionType.addParameter(functionType, functionParam);
             if (functionParam.hasDeclaredType) {
-                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionParam.type));
+                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionParam.type), functionType.details.typeVarScopeId);
             }
             if (param.name) {
                 const variadicParamType = transformVariadicParamType(node, param.category, functionParam.type);