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

package/dist/analyzer/typeEvaluator.js

@@ -1109,7 +1109,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            var _a;
             if ((0, types_1.isClass)(subtype)) {
                 if (subtype.priv.literalValue !== undefined) {
                     subtype = types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
@@ -1118,9 +1117,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Handle "LiteralString" specially.
                     if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
                         let strInstance = types_1.ClassType.cloneAsInstance(strClass);
-                        if ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) {
-                            strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
-                        }
+                        strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
                         return strInstance;
                     }
                 }
@@ -1554,10 +1551,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return undefined;
     }
     function getBoundMagicMethod(classType, memberName, selfType, diag, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return undefined;
-        }
-        recursionCount++;
         const boundMethodResult = getTypeOfBoundMember(
         /* errorNode */ undefined, classType, memberName, 
         /* usage */ undefined, diag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, selfType, recursionCount);
@@ -1568,6 +1561,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
+            if (recursionCount > types_1.maxTypeRecursionCount) {
+                return undefined;
+            }
+            recursionCount++;
             return getBoundMagicMethod(boundMethodResult.type, '__call__', selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), diag, recursionCount);
         }
         if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
@@ -2308,7 +2305,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isTypeAlias = !!declaredType && (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias');
         if (declaredType && !isTypeAlias) {
             let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            if (!assignType(declaredType, typeResult.type, diagAddendum)) {
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(nameNode);
+            const boundDeclaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveScopeIds);
+            const srcType = (0, typeUtils_1.makeTypeVarsBound)(typeResult.type, liveScopeIds);
+            if (!assignType(boundDeclaredType, srcType, diagAddendum)) {
                 // If there was an expected type mismatch, use that diagnostic
                 // addendum because it will be more informative.
                 if (expectedTypeDiagAddendum) {
@@ -2714,6 +2714,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         useBoundTypeVars: types_1.TypeVarType.isBound(subtype),
                     });
                 }
+                if (subtype.priv.isUnpacked && (0, types_1.isClass)(boundType)) {
+                    boundType = types_1.ClassType.cloneForUnpacked(boundType);
+                }
                 boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
                 return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
             }
@@ -2890,11 +2893,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                const annotationType = getTypeOfAnnotation(target.d.annotation, {
+                let annotationType = getTypeOfAnnotation(target.d.annotation, {
                     varTypeAnnotation: true,
                     allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(target.d.valueExpr),
                     allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(target.d.valueExpr),
                 });
+                if (annotationType) {
+                    const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(target);
+                    annotationType = (0, typeUtils_1.makeTypeVarsBound)(annotationType, liveScopeIds);
+                }
                 // Handle a bare "Final" or "ClassVar" in a special manner.
                 const isBareFinalOrClassVar = (0, types_1.isClassInstance)(annotationType) &&
                     (types_1.ClassType.isBuiltIn(annotationType, 'Final') || types_1.ClassType.isBuiltIn(annotationType, 'ClassVar'));
@@ -3143,6 +3150,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                 type = validateSymbolIsTypeExpression(node, type, !!effectiveTypeInfo.includesVariableDecl);
             }
+            if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
+                type = validateTypeVarUsage(node, type, flags);
+            }
             // Add TypeForm details if appropriate.
             type = addTypeFormForSymbol(node, type, flags, !!effectiveTypeInfo.includesVariableDecl);
         }
@@ -3156,7 +3166,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 type = types_1.UnknownType.create();
             }
         }
-        if ((0, types_1.isParamSpec)(type)) {
+        if ((0, types_1.isParamSpec)(type) && type.priv.scopeId) {
             if (flags & 32 /* EvalFlags.NoParamSpec */) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), node);
                 type = types_1.UnknownType.create();
@@ -3173,9 +3183,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
-            type = validateTypeVarUsage(node, type, flags);
-        }
         return { type, isIncomplete };
     }
     function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
@@ -3231,7 +3238,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             return true;
         }
-        if ((0, types_1.isTypeVar)(type) && !type.priv.scopeId) {
+        if ((0, types_1.isTypeVar)(type)) {
             return true;
         }
         // Exempts class types that are created by calling NewType, NamedTuple, etc.
@@ -3470,7 +3477,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (type.priv.scopeId && !scopedTypeVarInfo.foundInterveningClass) {
                 return type;
             }
-            if (!type.shared.isSynthesized) {
+            if (!type.shared.isSynthesized && (flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
                 const message = (0, types_1.isParamSpec)(type)
                     ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
                     : localize_1.LocMessage.typeVarNotUsedByOuterScope();
@@ -5559,7 +5566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0) {
                 // If it's an Annotated[a, b, c], only the first index should be
-                // treated as a type.The others can be regular(non - type) objects.
+                // treated as a type. The others can be regular (non-type) objects.
                 adjFlags =
                     32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */ | 2 /* EvalFlags.NoSpecialize */ | 131072 /* EvalFlags.NoClassVar */;
                 if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node))) {
@@ -5638,10 +5645,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isTypeVar)(type)) {
             const upperBound = type.shared.boundType;
             if (upperBound && (0, types_1.isClassInstance)(upperBound) && (0, typeUtils_1.isTupleClass)(upperBound)) {
-                const concrete = makeTopLevelTypeVarsConcrete(type);
-                if ((0, types_1.isInstantiableClass)(concrete)) {
-                    return types_1.ClassType.cloneForUnpacked(concrete);
-                }
+                return types_1.TypeVarType.cloneForUnpacked(type);
             }
             return undefined;
         }
@@ -7216,7 +7220,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function evaluateCastCall(argList, errorNode) {
         var _a;
         // Verify that the cast is necessary.
-        const castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        let castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        castToType = (0, typeUtils_1.makeTypeVarsBound)(castToType, liveScopeIds);
         let castFromType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
         if ((_a = castFromType.props) === null || _a === void 0 ? void 0 : _a.specialForm) {
             castFromType = castFromType.props.specialForm;
@@ -7449,7 +7455,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const paramInfo = paramDetails.params[paramIndex];
             const paramType = paramInfo.type;
             const paramName = paramInfo.param.name;
-            const isParamVariadic = paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && (0, types_1.isTypeVarTuple)(paramType);
+            const isParamVariadic = paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && (0, types_1.isUnpacked)(paramType);
             if (argList[argIndex].argCategory === 1 /* ArgCategory.UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
                 const argTypeResult = getTypeOfArg(argList[argIndex], /* inferenceContext */ undefined);
@@ -7581,7 +7587,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         paramType.priv.tupleTypeArgs.length > 0) {
                         effectiveParamType = paramType.priv.tupleTypeArgs[0].type;
                     }
-                    paramCategory = (0, types_1.isTypeVarTuple)(effectiveParamType) ? 1 /* ParamCategory.ArgsList */ : 0 /* ParamCategory.Simple */;
+                    paramCategory = (0, types_1.isUnpacked)(effectiveParamType) ? 1 /* ParamCategory.ArgsList */ : 0 /* ParamCategory.Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
                             if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -8060,7 +8066,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 !isTypeVarTupleFullyMatched) {
                 const paramType = paramDetails.params[paramDetails.argsIndex].type;
                 const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
-                if ((0, types_1.isTypeVarTuple)(paramType) && !paramType.priv.isInUnion) {
+                if ((0, types_1.isUnpacked)(paramType) && (!(0, types_1.isTypeVarTuple)(paramType) || !paramType.priv.isInUnion)) {
                     const tupleTypeArgs = variadicArgs.map((argParam) => {
                         var _a;
                         const argType = getTypeOfArg(argParam.argument, /* inferenceContext */ undefined).type;
@@ -8084,20 +8090,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         };
                     });
                     let specializedTuple;
-                    if (tupleTypeArgs.length === 1 &&
-                        !tupleTypeArgs[0].isUnbounded &&
-                        ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isTypeVarTuple)(tupleTypeArgs[0].type))) {
-                        // If there is a single unpacked tuple or unpacked variadic type variable
-                        // (including an unpacked TypeVarTuple union) within this tuple,
-                        // simplify the type.
-                        specializedTuple = tupleTypeArgs[0].type;
+                    if (tupleTypeArgs.length === 1 && !tupleTypeArgs[0].isUnbounded) {
+                        const entryType = tupleTypeArgs[0].type;
+                        if ((0, types_1.isUnpacked)(entryType)) {
+                            specializedTuple = (0, typeUtils_1.makePacked)(entryType);
+                        }
                     }
-                    else {
-                        specializedTuple = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs, /* isUnpacked */ true);
+                    if (!specializedTuple) {
+                        specializedTuple = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs, /* isUnpacked */ false);
                     }
                     const combinedArg = {
-                        paramCategory: 1 /* ParamCategory.ArgsList */,
-                        paramType,
+                        paramCategory: 0 /* ParamCategory.Simple */,
+                        paramType: (0, typeUtils_1.makePacked)(paramType),
                         requiresTypeVarMatching: true,
                         argument: {
                             argCategory: 0 /* ArgCategory.Simple */,
@@ -8423,7 +8427,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
-            specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpacked */ false);
+            specializedReturnType = types_1.ClassType.cloneForPacked(specializedReturnType);
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
@@ -10690,16 +10694,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // As per the specification, we support None, int, bool, str, bytes literals
         // plus enum values.
         const literalTypes = [];
+        let isValidTypeForm = true;
         for (const item of node.d.items) {
             let type;
             const itemExpr = item.d.valueExpr;
             if (item.d.argCategory !== 0 /* ArgCategory.Simple */) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
-                type = types_1.UnknownType.create();
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
             }
             else if (item.d.name) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
-                type = types_1.UnknownType.create();
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
             }
             else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */) {
                 const isBytes = (itemExpr.d.strings[0].d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
@@ -10710,11 +10721,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
                 }
-                itemExpr.d.strings.forEach((stringNode) => {
-                    if ((stringNode.d.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
-                    }
-                });
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    itemExpr.d.strings.forEach((stringNode) => {
+                        if ((stringNode.d.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
+                            isValidTypeForm = false;
+                        }
+                    });
+                }
             }
             else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
                 if (!itemExpr.d.isImaginary && itemExpr.d.isInteger) {
@@ -10770,6 +10784,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
                     type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
                 }
                 else {
                     return types_1.ClassType.cloneAsInstance(classType);
@@ -10781,7 +10796,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
             result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
-        if (isTypeFormSupported(node)) {
+        if (isTypeFormSupported(node) && isValidTypeForm) {
             result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
         }
         return result;
@@ -11641,8 +11656,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!rightHandType) {
-            // Determine whether there is a declared type.
-            const declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
             let typeAliasNameNode;
             let typeAliasPlaceholder;
             let isSpeculativeTypeAlias = false;
@@ -11686,6 +11699,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     writeTypeCache(node.d.leftExpr.d.valueExpr, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 }
             }
+            let declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
+            if (declaredType) {
+                const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
+            }
             const srcTypeResult = getTypeOfExpression(node.d.rightExpr, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
             rightHandType = srcTypeResult.type;
             expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
@@ -13328,7 +13346,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return type;
                 }
                 if ((0, types_1.isUnpackedClass)(type)) {
-                    return types_1.ClassType.cloneForUnpacked(type, /* isUnpacked */ false);
+                    return types_1.ClassType.cloneForPacked(type);
                 }
                 return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
             }
@@ -15419,7 +15437,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (paramDecl) {
                                 declarations.push(paramDecl);
                             }
-                            else if (types_1.ClassType.isDataClass(baseType) || types_1.ClassType.isTypedDictClass(baseType)) {
+                            else if (types_1.ClassType.isDataClass(baseType) ||
+                                types_1.ClassType.isTypedDictClass(baseType) ||
+                                types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
                                 const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
                                 if (lookupResults) {
                                     (0, collectionUtils_1.appendArray)(declarations, lookupResults.symbol.getDeclarations());
@@ -17404,6 +17424,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
+                // Handle the case where the source is an unpacked tuple.
+                if (!destType.priv.isUnpacked &&
+                    concreteSrcType.priv.isUnpacked &&
+                    concreteSrcType.priv.tupleTypeArgs) {
+                    return assignType(destType, (0, typeUtils_1.combineTupleTypeArgs)(concreteSrcType.priv.tupleTypeArgs), diag, constraints, flags, recursionCount);
+                }
                 // Handle enum literals that are assignable to another (non-Enum) literal.
                 // This can happen for IntEnum and StrEnum members.
                 if (types_1.ClassType.isEnumClass(concreteSrcType) &&
@@ -18322,11 +18348,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const destParamName = (_c = destParam.param.name) !== null && _c !== void 0 ? _c : '';
             const srcParamName = (_d = srcParam.param.name) !== null && _d !== void 0 ? _d : '';
             if (destParamName) {
-                const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional;
+                const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional || destParam.kind === parameterUtils_1.ParamKind.ExpandedArgs;
                 if (!isDestPositionalOnly &&
                     destParam.param.category !== 1 /* ParamCategory.ArgsList */ &&
                     srcParam.param.category !== 1 /* ParamCategory.ArgsList */) {
-                    if (srcParam.kind === parameterUtils_1.ParamKind.Positional) {
+                    if (srcParam.kind === parameterUtils_1.ParamKind.Positional || srcParam.kind === parameterUtils_1.ParamKind.ExpandedArgs) {
                         diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamPositionOnly().format({
                             name: destParamName,
                         }));