@zzzen/pyright-internal 1.2.0-dev.20230924 → 1.2.0-dev.20231001

package/dist/analyzer/typeEvaluator.js

@@ -103,6 +103,7 @@ const nonSubscriptableBuiltinTypes = new Map([
 const typePromotions = new Map([
     ['builtins.float', ['builtins.int']],
     ['builtins.complex', ['builtins.float', 'builtins.int']],
+    ['builtins.bytes', ['builtins.bytearray', 'builtins.memoryview']],
 ]);
 // How many levels deep should we attempt to infer return
 // types based on call-site argument types? The deeper we go,
@@ -391,6 +392,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        if (type) {
+            type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
+        }
         return type;
     }
     function getTypeResult(node) {
@@ -658,6 +662,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (expectingInstantiable) {
             validateTypeIsInstantiable(typeResult, flags, node);
         }
+        // Should we disable type promotions for bytes?
+        if ((0, types_1.isInstantiableClass)(typeResult.type) &&
+            typeResult.type.includePromotions &&
+            !typeResult.type.includeSubclasses &&
+            types_1.ClassType.isBuiltIn(typeResult.type, 'bytes')) {
+            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.disableBytesTypePromotions) {
+                typeResult = {
+                    ...typeResult,
+                    type: types_1.ClassType.cloneRemoveTypePromotions(typeResult.type),
+                };
+            }
+        }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
         // If there was an expected type, make sure that the result type is compatible.
         if (inferenceContext &&
@@ -928,6 +944,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
                     isIncomplete,
                 };
+                if ((0, types_1.isClass)(typeResult.type) && typeResult.type.includePromotions) {
+                    typeResult.type = types_1.ClassType.cloneRemoveTypePromotions(typeResult.type);
+                }
             }
         }
         else {
@@ -1294,7 +1313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !types_1.ClassType.isBuiltIn(metaclass, 'type') &&
             !types_1.ClassType.isSameGenericClass(metaclass, classType)) {
             const metaclassMemberInfo = getTypeOfClassMemberName(errorNode, metaclass, 
-            /* isAccessedThroughObject */ false, memberName, usage, metaclassDiag, memberAccessFlags, classType);
+            /* isAccessedThroughObject */ false, memberName, usage, metaclassDiag, memberAccessFlags | 128 /* SkipAttributeAccessOverride */, classType);
             if (metaclassMemberInfo && (0, typeUtils_1.isDescriptorInstance)(metaclassMemberInfo.type)) {
                 considerMetaclassOnly = true;
             }
@@ -2326,20 +2345,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     // If the type includes promotion types, expand these to their constituent types.
-    function expandPromotionTypes(node, type) {
+    function expandPromotionTypes(node, type, excludeBytes = false) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if (!(0, types_1.isClass)(subtype) || !subtype.includePromotions) {
                 return subtype;
             }
-            const typesToCombine = [types_1.ClassType.cloneForPromotionType(subtype, /* includePromotions */ false)];
+            if (excludeBytes && types_1.ClassType.isBuiltIn(subtype, 'bytes')) {
+                return subtype;
+            }
+            const typesToCombine = [types_1.ClassType.cloneRemoveTypePromotions(subtype)];
             const promotionTypeNames = typePromotions.get(subtype.details.fullName);
             if (promotionTypeNames) {
                 for (const promotionTypeName of promotionTypeNames) {
                     const nameSplit = promotionTypeName.split('.');
                     let promotionSubtype = getBuiltInType(node, nameSplit[nameSplit.length - 1]);
                     if (promotionSubtype && (0, types_1.isInstantiableClass)(promotionSubtype)) {
-                        promotionSubtype = types_1.ClassType.cloneForPromotionType(promotionSubtype, 
-                        /* includePromotions */ false);
+                        promotionSubtype = types_1.ClassType.cloneRemoveTypePromotions(promotionSubtype);
                         if ((0, types_1.isClassInstance)(subtype)) {
                             promotionSubtype = types_1.ClassType.cloneAsInstance(promotionSubtype);
                         }
@@ -2562,6 +2583,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             inferTypeParameterVarianceForClass(type);
             let typeWasTransformed = false;
             const filteredTypeArgs = type.typeArguments.map((typeArg, index) => {
+                if (index > type.details.typeParameters.length) {
+                    return typeArg;
+                }
                 const variance = types_1.TypeVarType.getVariance(type.details.typeParameters[index]);
                 if (variance !== 3 /* Covariant */) {
                     return typeArg;
@@ -3459,8 +3483,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isParamSpec)(baseType) && baseType.paramSpecAccess) {
             baseType = makeTopLevelTypeVarsConcrete(baseType);
         }
-        // Do union expansion for promotion types.
-        baseType = expandPromotionTypes(node, baseType);
         switch (baseType.category) {
             case 2 /* Any */:
             case 1 /* Unknown */:
@@ -6150,9 +6172,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // intended behavior according to PEP 484.
                 const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
                 if (!matchResults.argumentErrors) {
+                    // If there is an expected return type, see if it's potentially compatible
+                    // with this overload's return type. If not, we'll de-emphasize this overload.
                     if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType) {
                         const returnType = getFunctionEffectiveReturnType(matchResults.overload);
-                        if (!assignType(inferenceContext.expectedType, returnType, 
+                        if (!assignType((0, typeUtils_1.replaceTypeVarsWithAny)(inferenceContext.expectedType), (0, typeUtils_1.replaceTypeVarsWithAny)(returnType), 
                         /* diag */ undefined, 
                         /* destTypeVarContext */ undefined, 
                         /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
@@ -10169,7 +10193,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function cloneBuiltinObjectWithLiteral(node, builtInName, value) {
         const type = getBuiltInObject(node, builtInName);
         if ((0, types_1.isClassInstance)(type)) {
-            return types_1.ClassType.cloneWithLiteral(type, value);
+            return types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneRemoveTypePromotions(type), value);
         }
         return types_1.UnknownType.create();
     }
@@ -11768,7 +11792,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         node.parameters.forEach((param) => {
             var _a;
             const paramSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
-            (0, debug_1.assert)(paramSymbol);
+            if (!paramSymbol) {
+                // This can happen if the code is unreachable.
+                return;
+            }
             const typeOfParam = (_a = getDeclaredTypeOfSymbol(paramSymbol, param.name)) === null || _a === void 0 ? void 0 : _a.type;
             if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
                 return;
@@ -12197,7 +12224,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             let defaultValueType;
             if (param.defaultValue) {
-                defaultValueType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
+                // If this is a stub file, a protocol, an overload, or a class
+                // whose body is a placeholder implementation, treat a "...", as
+                // an "Any" value.
+                let treatEllipsisAsAny = fileInfo.isStubFile || ParseTreeUtils.isSuiteEmpty(node.suite);
+                if (containingClassType && types_1.ClassType.isProtocolClass(containingClassType)) {
+                    treatEllipsisAsAny = true;
+                }
+                if (types_1.FunctionType.isOverloaded(functionType) || types_1.FunctionType.isAbstractMethod(functionType)) {
+                    treatEllipsisAsAny = true;
+                }
+                defaultValueType = getTypeOfExpression(param.defaultValue, treatEllipsisAsAny ? 1 /* ConvertEllipsisToAny */ : 0 /* None */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
             }
             if (annotatedType) {
                 // If there was both a type annotation and a default value, verify
@@ -15620,6 +15657,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             sourceType: srcErrorTypeText,
             destType: destErrorTypeText,
         }));
+        // Tell the user about the disableBytesTypePromotions if that is involved.
+        if (types_1.ClassType.isBuiltIn(destType, 'bytes')) {
+            const promotions = typePromotions.get(destType.details.fullName);
+            if (promotions && promotions.some((name) => name === srcType.details.fullName)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.bytesTypePromotions());
+            }
+        }
         return false;
     }
     // This function is used to validate or infer the variance of type
@@ -15968,6 +16012,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (includeDiagAddendum) {
                                 childDiag.addAddendum(assignmentDiag);
                             }
+                            if (isCompatible && types_1.ClassType.isSameGenericClass(destType, srcType)) {
+                                // Add additional notes to help the user if this is a common type mismatch.
+                                if (types_1.ClassType.isBuiltIn(destType, 'dict') && srcArgIndex === 1) {
+                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionDict());
+                                }
+                                else if (types_1.ClassType.isBuiltIn(destType, 'list')) {
+                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionList());
+                                }
+                            }
                         }
                         else {
                             diag.addAddendum(assignmentDiag);