@zzzen/pyright-internal 1.2.0-dev.20220814 → 1.2.0-dev.20220821

package/dist/analyzer/typeEvaluator.js

@@ -1884,11 +1884,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return (suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode)) ||
             speculativeTypeTracker.isSpeculative(node));
     }
-    function addDiagnostic(diagLevel, rule, message, node) {
+    function addDiagnostic(diagLevel, rule, message, node, range) {
         if (diagLevel === 'none') {
             return undefined;
         }
-        const diagnostic = addDiagnosticWithSuppressionCheck(diagLevel, message, node);
+        const diagnostic = addDiagnosticWithSuppressionCheck(diagLevel, message, node, range);
         if (diagnostic) {
             diagnostic.setRule(rule);
         }
@@ -1917,6 +1917,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeExpectedClass().format({ type: printType(type) }) + diag.getString(), node);
     }
     function assignTypeToNameNode(nameNode, type, isTypeIncomplete, ignoreEmptyContainers, srcExpression, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
+        var _a, _b;
         const nameValue = nameNode.value;
         const symbolWithScope = lookUpSymbolRecursive(nameNode, nameValue, /* honorCodeFlow */ false);
         if (!symbolWithScope) {
@@ -1954,7 +1955,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatch().format({
                     sourceType: printType(type),
                     destType: printType(declaredType),
-                }) + diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode);
+                }) + diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_b = (_a = diagAddendum.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : srcExpression) !== null && _b !== void 0 ? _b : nameNode);
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
             }
@@ -3145,7 +3146,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
-        var _a;
+        var _a, _b;
         let baseType = baseTypeResult.type;
         const memberName = node.memberName.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -3415,7 +3416,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const [ruleSet, rule] = isFunctionRule
                     ? [fileInfo.diagnosticRuleSet.reportFunctionMemberAccess, diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess]
                     : [fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues];
-                addDiagnostic(ruleSet, rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName);
+                addDiagnostic(ruleSet, rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : node.memberName);
             }
             // If this is member access on a function, use "Any" so if the
             // reportFunctionMemberAccess rule is disabled, we don't trigger
@@ -3436,7 +3437,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // It can also come up in cases like "isinstance(x, (list, dict))".
             if ((0, types_1.isInstantiableClass)(type)) {
                 const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* Argument */);
-                if (argNode && ((_a = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
+                if (argNode && ((_b = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 9 /* Call */) {
                     skipPartialUnknownCheck = true;
                 }
             }
@@ -7207,6 +7208,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return !reportedArgError;
     }
     function validateArgType(argParam, typeVarContext, functionType, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+        var _a;
         let argType;
         let expectedTypeDiag;
         let isTypeIncomplete = false;
@@ -7380,7 +7382,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiag) {
                     diag = expectedTypeDiag;
                 }
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode);
+                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
             }
             return { isCompatible: false, argType, isTypeIncomplete, condition };
         }
@@ -8435,7 +8437,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
             if (types_1.ClassType.isTypedDictClass(expectedType)) {
-                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, expectedType, keyTypes, valueTypes, expectedDiagAddendum);
+                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, expectedType, keyTypes, valueTypes, 
+                // Don't overwrite existing expectedDiagAddendum messages if they were
+                // already provided by getKeyValueTypesFromDictionary.
+                (expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.isEmpty()) ? expectedDiagAddendum : undefined);
                 if (resultTypedDict) {
                     return {
                         type: resultTypedDict,
@@ -8469,8 +8474,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // and Iterable use covariant value types, so they can be narrowed.
         const isValueTypeInvariant = (0, types_1.isClassInstance)(expectedType) &&
             (types_1.ClassType.isBuiltIn(expectedType, 'dict') || types_1.ClassType.isBuiltIn(expectedType, 'MutableMapping'));
-        const specializedKeyType = inferTypeArgFromExpectedType(expectedKeyType, keyTypes, /* isNarrowable */ false);
-        const specializedValueType = inferTypeArgFromExpectedType(expectedValueType, valueTypes, 
+        const specializedKeyType = inferTypeArgFromExpectedType(expectedKeyType, keyTypes.map((result) => result.type), 
+        /* isNarrowable */ false);
+        const specializedValueType = inferTypeArgFromExpectedType(expectedValueType, valueTypes.map((result) => result.type), 
         /* isNarrowable */ !isValueTypeInvariant);
         if (!specializedKeyType || !specializedValueType) {
             return undefined;
@@ -8484,17 +8490,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const fallbackType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
         let keyType = fallbackType;
         let valueType = fallbackType;
-        let keyTypes = [];
-        let valueTypes = [];
+        const keyTypeResults = [];
+        const valueTypeResults = [];
         let isEmptyContainer = false;
         let isIncomplete = false;
         // Infer the key and value types if possible.
-        if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, /* forceStrictInference */ hasExpectedType)) {
+        if (getKeyAndValueTypesFromDictionary(node, keyTypeResults, valueTypeResults, 
+        /* forceStrictInference */ hasExpectedType)) {
             isIncomplete = true;
         }
         // Strip any literal values.
-        keyTypes = keyTypes.map((t) => stripLiteralValue(t));
-        valueTypes = valueTypes.map((t) => stripLiteralValue(t));
+        const keyTypes = keyTypeResults.map((t) => stripLiteralValue(t.type));
+        const valueTypes = valueTypeResults.map((t) => stripLiteralValue(t.type));
         keyType = keyTypes.length > 0 ? (0, types_1.combineTypes)(keyTypes) : fallbackType;
         // If the value type differs and we're not using "strict inference mode",
         // we need to back off because we can't properly represent the mappings
@@ -8556,8 +8563,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncomplete = true;
                 }
                 if (forceStrictInference || index < maxEntriesToUseForInference) {
-                    keyTypes.push(keyType);
-                    valueTypes.push(valueType);
+                    keyTypes.push({ node: entryNode.keyExpression, type: keyType });
+                    valueTypes.push({ node: entryNode.valueExpression, type: valueType });
                 }
                 addUnknown = false;
             }
@@ -8578,8 +8585,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* allowNarrowed */ true);
                         tdEntries.forEach((entry, name) => {
                             if (entry.isRequired || entry.isProvided) {
-                                keyTypes.push(types_1.ClassType.cloneWithLiteral(strObject, name));
-                                valueTypes.push(entry.valueType);
+                                keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneWithLiteral(strObject, name) });
+                                valueTypes.push({ node: entryNode, type: entry.valueType });
                             }
                         });
                         addUnknown = false;
@@ -8604,8 +8611,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const typeArgs = specializedMapping.typeArguments;
                             if (typeArgs && typeArgs.length >= 2) {
                                 if (forceStrictInference || index < maxEntriesToUseForInference) {
-                                    keyTypes.push(typeArgs[0]);
-                                    valueTypes.push(typeArgs[1]);
+                                    keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                                    valueTypes.push({ node: entryNode, type: typeArgs[1] });
                                 }
                                 addUnknown = false;
                             }
@@ -8628,8 +8635,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeArgs = (_a = dictEntryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.map((t) => t.type);
                     if (typeArgs && typeArgs.length === 2) {
                         if (forceStrictInference || index < maxEntriesToUseForInference) {
-                            keyTypes.push(typeArgs[0]);
-                            valueTypes.push(typeArgs[1]);
+                            keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                            valueTypes.push({ node: entryNode, type: typeArgs[1] });
                         }
                         addUnknown = false;
                     }
@@ -8637,8 +8644,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (addUnknown) {
                 if (forceStrictInference || index < maxEntriesToUseForInference) {
-                    keyTypes.push(types_1.UnknownType.create());
-                    valueTypes.push(types_1.UnknownType.create());
+                    keyTypes.push({ node: entryNode, type: types_1.UnknownType.create() });
+                    valueTypes.push({ node: entryNode, type: types_1.UnknownType.create() });
                 }
             }
         });