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

package/dist/analyzer/typeEvaluator.js

@@ -392,6 +392,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        if (type) {
+            type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
+        }
         return type;
     }
     function getTypeResult(node) {
@@ -659,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 &&
@@ -929,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 {
@@ -1295,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,6 +2344,34 @@ 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, excludeBytes = false) {
+        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            if (!(0, types_1.isClass)(subtype) || !subtype.includePromotions) {
+                return subtype;
+            }
+            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.cloneRemoveTypePromotions(promotionSubtype);
+                        if ((0, types_1.isClassInstance)(subtype)) {
+                            promotionSubtype = types_1.ClassType.cloneAsInstance(promotionSubtype);
+                        }
+                        promotionSubtype = (0, typeUtils_1.addConditionToType)(promotionSubtype, subtype.condition);
+                        typesToCombine.push(promotionSubtype);
+                    }
+                }
+            }
+            return (0, types_1.combineTypes)(typesToCombine);
+        });
+    }
     // Replaces all of the top-level TypeVars (as opposed to TypeVars
     // used as type arguments in other types) with their concrete form.
     // If conditionFilter is specified and the TypeVar is a constrained
@@ -2537,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;
@@ -3410,7 +3459,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isNotRequired = false;
         // If the base type was incomplete and unbound, don't proceed
         // because false positive errors will be generated.
-        if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseTypeResult.type)) {
+        if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseType)) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
         // Handle the special case where the expression is an actual
@@ -6109,6 +6158,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateOverloadedFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         let filteredMatchResults = [];
         let contextFreeArgTypes;
+        let isTypeIncomplete = !!typeResult.isIncomplete;
         // Start by evaluating the types of the arguments without any expected
         // type. Also, filter the list of overloads based on the number of
         // positional and named arguments that are present. We do all of this
@@ -6122,6 +6172,17 @@ 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((0, typeUtils_1.replaceTypeVarsWithAny)(inferenceContext.expectedType), (0, typeUtils_1.replaceTypeVarsWithAny)(returnType), 
+                        /* diag */ undefined, 
+                        /* destTypeVarContext */ undefined, 
+                        /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+                            matchResults.relevance += -0.5;
+                        }
+                    }
                     filteredMatchResults.push(matchResults);
                 }
                 overloadIndex++;
@@ -6149,7 +6210,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
             }
-            return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
+            return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
         }
         // Create a helper function that evaluates the overload that best
         // matches the arg/param lists.
@@ -6175,7 +6236,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return evaluateUsingBestMatchingOverload(/* skipUnknownArgCheck */ false);
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
-        let isTypeIncomplete = !!typeResult.isIncomplete;
         while (true) {
             const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
             if (callResult.isTypeIncomplete) {
@@ -6221,7 +6281,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             result.returnType = types_1.UnknownType.create();
             return { ...result, argumentErrors: true };
         }
-        return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
+        return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
     }
     // Replaces each item in the expandedArgTypes with n items where n is
     // the number of subtypes in a union. The contextFreeArgTypes parameter
@@ -10133,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();
     }
@@ -11145,6 +11205,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined, ParseTreeUtils.getDocString(node.suite.statements));
         classType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        // Is this a special type that supports type promotions according to PEP 484?
+        if (typePromotions.has(classType.details.fullName)) {
+            classType.includePromotions = true;
+        }
         // Some classes refer to themselves within type arguments used within
         // base classes. We'll register the partially-constructed class type
         // to allow these to be resolved.
@@ -11728,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;
@@ -12157,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
@@ -15526,11 +15603,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return true;
         }
         // Handle special-case type promotions.
-        const promotionList = typePromotions.get(destType.details.fullName);
-        if (promotionList &&
-            promotionList.some((srcName) => srcType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && srcName === mroClass.details.fullName))) {
-            if ((flags & 1 /* EnforceInvariance */) === 0) {
-                return true;
+        if (destType.includePromotions) {
+            const promotionList = typePromotions.get(destType.details.fullName);
+            if (promotionList &&
+                promotionList.some((srcName) => srcType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && srcName === mroClass.details.fullName))) {
+                if ((flags & 1 /* EnforceInvariance */) === 0) {
+                    return true;
+                }
             }
         }
         // Is it a structural type (i.e. a protocol)? If so, we need to
@@ -15578,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
@@ -15926,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);
@@ -16310,7 +16405,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Handle LiteralString special form.
                 if (types_1.ClassType.isBuiltIn(destType, 'LiteralString')) {
                     if (types_1.ClassType.isBuiltIn(concreteSrcType, 'str') && concreteSrcType.literalValue !== undefined) {
-                        return true;
+                        return (flags & 1 /* EnforceInvariance */) === 0;
                     }
                     else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString')) {
                         return true;
@@ -16318,7 +16413,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
                     strClassType &&
-                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    (0, types_1.isInstantiableClass)(strClassType) &&
+                    (flags & 1 /* EnforceInvariance */) === 0) {
                     concreteSrcType = types_1.ClassType.cloneAsInstance(strClassType);
                 }
                 if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
@@ -16570,7 +16666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // If we have no src subtypes remaining but not all dest types have been subsumed
                     // by other dest types, then the types are not compatible if we're enforcing invariance.
                     if (remainingSrcSubtypes.length === 0) {
-                        return remainingDestSubtypes.every((destSubtype) => isTypeSubsumedByOtherType(destSubtype, destType.subtypes, 
+                        return remainingDestSubtypes.every((destSubtype) => isTypeSubsumedByOtherType(destSubtype, destType, 
                         /* allowAnyToSubsume */ true, recursionCount));
                     }
                 }
@@ -16627,7 +16723,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                 // Determine if the current subtype is subsumed by another subtype
                 // in the same union. If so, we can ignore this.
-                const isSubtypeSubsumed = isTypeSubsumedByOtherType(subtype, srcType.subtypes, 
+                const isSubtypeSubsumed = isTypeSubsumedByOtherType(subtype, srcType, 
                 /* allowAnyToSubsume */ false, recursionCount);
                 // Try again with a concrete version of the subtype.
                 if (!isSubtypeSubsumed &&
@@ -16643,9 +16739,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return true;
     }
     // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) one
-    // of the other types in a list.
-    function isTypeSubsumedByOtherType(type, otherTypes, allowAnyToSubsume, recursionCount = 0) {
+    // of the other type.
+    function isTypeSubsumedByOtherType(type, otherType, allowAnyToSubsume, recursionCount = 0) {
         const concreteType = makeTopLevelTypeVarsConcrete(type);
+        const otherTypes = (0, types_1.isUnion)(otherType) ? otherType.subtypes : [otherType];
         for (const otherType of otherTypes) {
             if ((0, types_1.isTypeSame)(otherType, type)) {
                 continue;
@@ -18402,7 +18499,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         validateInitSubclassArgs,
         isAfterNodeReachable,
         isNodeReachable,
-        isAsymmetricDescriptorAssignment: isAsymmetricAccessorAssignment,
+        isAsymmetricAccessorAssignment,
         suppressDiagnostics,
         getDeclarationsForStringNode,
         getDeclarationsForNameNode,
@@ -18414,8 +18511,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getGetterTypeFromProperty,
         getTypeOfArgument,
         markNamesAccessed,
+        expandPromotionTypes,
         makeTopLevelTypeVarsConcrete,
         mapSubtypesExpandTypeVars,
+        isTypeSubsumedByOtherType,
         lookUpSymbolRecursive,
         getDeclaredTypeOfSymbol,
         getEffectiveTypeOfSymbol,