@zzzen/pyright-internal 1.2.0-dev.20241013 → 1.2.0-dev.20241020

package/dist/analyzer/typeEvaluator.js

@@ -158,6 +158,11 @@ const maxInferFunctionReturnRecursionCount = 12;
 // it can increase the chance of false negatives for such recursive
 // type aliases.
 const maxRecursiveTypeAliasRecursionCount = 10;
+// Normally a symbol can have only one type declaration, but there are
+// cases where multiple are possible (e.g. a property with a setter
+// and a deleter). In extreme cases, we need to limit the number of
+// type declarations we consider to avoid excessive computation.
+const maxTypedDeclsPerSymbol = 16;
 // This switch enables a special debug mode that attempts to catch
 // bugs due to inconsistent evaluation flags used when reading types
 // from the type cache.
@@ -892,7 +897,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) === 0 && (0, types_1.isTypeVarTuple)(iterType) && !iterType.priv.isUnpacked) {
             typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
         }
-        else if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0 &&
+        else if ((flags & 4194304 /* EvalFlags.AllowUnpackedTuple */) !== 0 &&
             (0, types_1.isInstantiableClass)(iterType) &&
             types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
             typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
@@ -999,7 +1004,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let typeResult;
         // In most cases, annotations within a string are not parsed by the interpreter.
         // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
-        if ((flags & 8388608 /* EvalFlags.ParsesStringLiteral */) === 0) {
+        if ((flags & 16777216 /* EvalFlags.ParsesStringLiteral */) === 0) {
             updatedFlags |= 524288 /* EvalFlags.NotParsed */;
         }
         updatedFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
@@ -2529,7 +2534,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Is this subtype a tuple?
             const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
             if (tupleType && tupleType.priv.tupleTypeArgs) {
-                const sourceEntryTypes = tupleType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype), /* skipSelfCondition */ true));
+                const sourceEntryTypes = tupleType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype), { skipSelfCondition: true }));
                 const unboundedIndex = tupleType.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded);
                 if (unboundedIndex >= 0) {
                     if (sourceEntryTypes.length < targetTypes.length) {
@@ -3538,7 +3543,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Walks up the parse tree to find a function, class, or type alias
     // declaration that provides the context for a type variable.
     function findScopedTypeVar(node, type) {
-        var _a;
+        var _a, _b;
         let curNode = node;
         let nestedClassCount = 0;
         (0, debug_1.assert)(types_1.TypeBase.isInstantiable(type));
@@ -3605,7 +3610,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // purposes of resolving type aliases?
                 if (leftType && (0, types_1.isTypeVar)(leftType) && leftType.shared.recursiveAlias) {
                     // Type alias statements cannot be used with old-style type variables.
-                    if (typeAliasNode && !type.shared.isTypeParamSyntax) {
+                    if (typeAliasNode && !type.shared.isTypeParamSyntax && !((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeParameterNotDeclared().format({
                             name: type.shared.name,
                             container: typeAliasNode.d.name.d.value,
@@ -3615,7 +3620,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // If this is a TypeAliasType call, the recursive type parameters will already
                         // be populated, and we need to verify that the type parameter is in the
                         // list of allowed type parameters.
-                        const allowedTypeParams = (_a = leftType.shared.recursiveAlias) === null || _a === void 0 ? void 0 : _a.typeParams;
+                        const allowedTypeParams = (_b = leftType.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.typeParams;
                         if (allowedTypeParams) {
                             if (!allowedTypeParams.some((param) => param.shared.name === type.shared.name)) {
                                 // Return the original type.
@@ -3835,8 +3840,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (typeResult) {
                     if (!typeResult.typeErrors) {
-                        type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
-                        /* skipSelfCondition */ true);
+                        type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), {
+                            skipSelfCondition: true,
+                            skipBoundTypeVars: true,
+                        });
                     }
                     else {
                         typeErrors = true;
@@ -3848,8 +3855,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         isIncomplete = true;
                     }
                     if (typeResult.narrowedTypeForSet) {
-                        narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(typeResult.narrowedTypeForSet, (0, typeUtils_1.getTypeCondition)(baseType), 
-                        /* skipSelfCondition */ true);
+                        narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(typeResult.narrowedTypeForSet, (0, typeUtils_1.getTypeCondition)(baseType), { skipSelfCondition: true, skipBoundTypeVars: true });
                     }
                     if (typeResult.memberAccessDeprecationInfo) {
                         memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
@@ -3939,7 +3945,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         (0, debug_1.assert)((0, types_1.isClassInstance)(subtype));
                         const typeResult = getTypeOfBoundMember(node.d.member, subtype, memberName, usage, diag);
                         if (typeResult && !typeResult.typeErrors) {
-                            type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
+                            type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), {
+                                skipBoundTypeVars: true,
+                            });
                             if (typeResult.isIncomplete) {
                                 isIncomplete = true;
                             }
@@ -5549,7 +5557,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* EvalFlags.NoClassVar */ | 16 /* EvalFlags.NoFinal */;
             }
-            adjFlags |= 2097152 /* EvalFlags.AllowUnpackedTuple */ | 134217728 /* EvalFlags.AllowConcatenate */;
+            adjFlags |= 4194304 /* EvalFlags.AllowUnpackedTuple */ | 134217728 /* EvalFlags.AllowConcatenate */;
         }
         // Create a local function that validates a single type argument.
         const getTypeArgTypeResult = (expr, argIndex) => {
@@ -5931,6 +5939,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!(0, types_1.isTypeSame)(assertedType, arg0Type, {
             treatAnySameAsUnknown: true,
             ignorePseudoGeneric: true,
+            ignoreConditions: true,
         })) {
             const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
@@ -8411,7 +8420,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 eliminateUnsolvedInUnions,
             },
         });
-        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition);
+        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition, { skipBoundTypeVars: true });
         // If the function includes a ParamSpec and the captured signature(s) includes
         // generic types, we may need to apply those solved TypeVars.
         if (paramSpecConstraints.length > 0) {
@@ -10967,13 +10976,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isUsageLegal = true;
             }
         }
-        if ((flags & 1048576 /* EvalFlags.AllowRequired */) !== 0) {
-            isUsageLegal = true;
-        }
         let isReadOnly = typeArgs[0].isReadOnly;
         let isRequired = typeArgs[0].isRequired;
         let isNotRequired = typeArgs[0].isNotRequired;
         if (classType.shared.name === 'ReadOnly') {
+            if ((flags & 2097152 /* EvalFlags.AllowReadOnly */) !== 0) {
+                isUsageLegal = true;
+            }
             // Nested ReadOnly are not allowed.
             if (typeArgs[0].isReadOnly) {
                 isUsageLegal = false;
@@ -10981,6 +10990,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isReadOnly = true;
         }
         else {
+            if ((flags & 1048576 /* EvalFlags.AllowRequired */) !== 0) {
+                isUsageLegal = true;
+            }
             // Nested Required/NotRequired are not allowed.
             if (typeArgs[0].isRequired || typeArgs[0].isNotRequired) {
                 isUsageLegal = false;
@@ -11008,7 +11020,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return classType;
         }
         const typeArgType = typeArgs[0].type;
-        if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
+        if ((flags & 4194304 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
             const unpackedType = applyUnpackToTupleLike(typeArgType);
             if (unpackedType) {
                 return unpackedType;
@@ -11019,7 +11031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
             return types_1.UnknownType.create();
         }
-        if ((flags & 4194304 /* EvalFlags.AllowUnpackedTypedDict */) !== 0) {
+        if ((flags & 8388608 /* EvalFlags.AllowUnpackedTypedDict */) !== 0) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isTypedDictClass(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
             }
@@ -12143,6 +12155,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
                                 classType.shared.flags |=
                                     8 /* ClassTypeFlags.TypedDictMarkedClosed */ | 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                if (classType.shared.typedDictExtraItemsExpr) {
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
+                                }
+                            }
+                        }
+                    }
+                    else if (arg.d.name.d.value === 'extra_items') {
+                        // This is an experimental feature because PEP 728 hasn't been accepted yet.
+                        if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                            // Record a reference to the expression but don't evaluate it yet.
+                            // It may refer to the class itself.
+                            classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
+                            classType.shared.flags |= 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                            if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                             }
                         }
                     }
@@ -13355,9 +13382,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
                     return type;
                 }
-                // Is this an unpacked TypedDict? If so, return it unmodified.
+                // Is this an unpacked TypedDict? If so, return its packed version.
                 if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isTypedDictClass(type) && type.priv.isUnpacked) {
-                    return type;
+                    return types_1.ClassType.cloneForPacked(type);
                 }
                 // Wrap the type in a dict with str keys.
                 const dictType = getBuiltInType(node, 'dict');
@@ -14971,7 +14998,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             flags |= 4 /* EvalFlags.ForwardRefs */;
         }
         else if (options === null || options === void 0 ? void 0 : options.parsesStringLiteral) {
-            flags |= 8388608 /* EvalFlags.ParsesStringLiteral */;
+            flags |= 16777216 /* EvalFlags.ParsesStringLiteral */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowFinal)) {
             flags |= 16 /* EvalFlags.NoFinal */;
@@ -14979,14 +15006,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options === null || options === void 0 ? void 0 : options.allowRequired) {
             flags |= 1048576 /* EvalFlags.AllowRequired */ | 256 /* EvalFlags.TypeExpression */;
         }
+        if (options === null || options === void 0 ? void 0 : options.allowReadOnly) {
+            flags |= 2097152 /* EvalFlags.AllowReadOnly */ | 256 /* EvalFlags.TypeExpression */;
+        }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTuple) {
-            flags |= 2097152 /* EvalFlags.AllowUnpackedTuple */;
+            flags |= 4194304 /* EvalFlags.AllowUnpackedTuple */;
         }
         else {
             flags |= 64 /* EvalFlags.NoTypeVarTuple */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
-            flags |= 4194304 /* EvalFlags.AllowUnpackedTypedDict */;
+            flags |= 8388608 /* EvalFlags.AllowUnpackedTypedDict */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
             flags |= 32 /* EvalFlags.NoParamSpec */;
@@ -15569,6 +15599,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         declaredType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(typeAnnotationNode, {
                             allowFinal: true,
                             allowRequired: true,
+                            allowReadOnly: true,
                         }).type);
                     }
                     else {
@@ -15581,6 +15612,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode),
                             allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode),
                             allowRequired: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
+                            allowReadOnly: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
                             enforceClassTypeVarScope: declaration.isDefinedByMemberAccess,
                         });
                     }
@@ -16260,23 +16292,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // cases where a property symbol is redefined to add a setter, deleter,
         // etc.
         if (usageNode && typedDecls.length > 1) {
-            const filteredTypedDecls = typedDecls.filter((decl) => {
-                if (decl.type !== 8 /* DeclarationType.Alias */) {
-                    // Is the declaration in the same execution scope as the "usageNode" node?
-                    const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
-                    const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
-                    if (usageScope === declScope) {
-                        if (!isFlowPathBetweenNodes(decl.node, usageNode, /* allowSelf */ false)) {
-                            return false;
+            if (typedDecls.length > maxTypedDeclsPerSymbol) {
+                // If there are too many typed decls, don't bother filtering them
+                // because this can be very expensive. Simply use the last one
+                // in this case.
+                typedDecls = [typedDecls[typedDecls.length - 1]];
+            }
+            else {
+                const filteredTypedDecls = typedDecls.filter((decl) => {
+                    if (decl.type !== 8 /* DeclarationType.Alias */) {
+                        // Is the declaration in the same execution scope as the "usageNode" node?
+                        const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
+                        const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
+                        if (usageScope === declScope) {
+                            if (!isFlowPathBetweenNodes(decl.node, usageNode, /* allowSelf */ false)) {
+                                return false;
+                            }
                         }
                     }
+                    return true;
+                });
+                if (filteredTypedDecls.length === 0) {
+                    return { type: types_1.UnboundType.create() };
                 }
-                return true;
-            });
-            if (filteredTypedDecls.length === 0) {
-                return { type: types_1.UnboundType.create() };
+                typedDecls = filteredTypedDecls;
             }
-            typedDecls = filteredTypedDecls;
         }
         // Start with the last decl. If that's already being resolved,
         // use the next-to-last decl, etc. This can happen when resolving
@@ -18407,6 +18447,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if (destParam.kind !== parameterUtils_1.ParamKind.Positional &&
+                destParam.kind !== parameterUtils_1.ParamKind.ExpandedArgs &&
                 srcParam.kind === parameterUtils_1.ParamKind.Positional &&
                 srcParamDetails.kwargsIndex === undefined &&
                 !srcParamDetails.params.some((p) => p.kind === parameterUtils_1.ParamKind.Keyword &&
@@ -18495,7 +18536,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (!assignParam(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                             canAssign = false;
                         }
-                        if (destParamDetails.params[paramIndex].kind !== parameterUtils_1.ParamKind.Positional &&
+                        const destParamKind = destParamDetails.params[paramIndex].kind;
+                        if (destParamKind !== parameterUtils_1.ParamKind.Positional &&
+                            destParamKind !== parameterUtils_1.ParamKind.ExpandedArgs &&
                             srcParamDetails.kwargsIndex === undefined) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
                                 name: (_g = destParamDetails.params[paramIndex].param.name) !== null && _g !== void 0 ? _g : '',
@@ -18569,7 +18612,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (index >= destParamDetails.firstKeywordOnlyIndex) {
                         if (param.param.name &&
                             param.param.category === 0 /* ParamCategory.Simple */ &&
-                            param.kind !== parameterUtils_1.ParamKind.Positional) {
+                            param.kind !== parameterUtils_1.ParamKind.Positional &&
+                            param.kind !== parameterUtils_1.ParamKind.ExpandedArgs) {
                             destParamMap.set(param.param.name, param);
                         }
                     }
@@ -19176,7 +19220,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
                     if (!types_1.FunctionParam.isNameSynthesized(baseParam) &&
-                        baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.Positional) {
+                        baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.Positional &&
+                        baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.ExpandedArgs) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                             index: i + 1,
                             baseName: baseParam.name || '*',