@zzzen/pyright-internal 1.2.0-dev.20250330 → 1.2.0-dev.20250406

package/dist/analyzer/typeEvaluator.js

@@ -2393,7 +2393,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!typeResult.isIncomplete) {
-            reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
+            reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, typeResult.type, nameNode, ignoreEmptyContainers);
         }
         writeTypeCache(nameNode, { type: destType, isIncomplete: typeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
@@ -2934,31 +2934,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                let annotationType = getTypeOfAnnotation(target.d.annotation, {
+                getTypeOfAnnotation(target.d.annotation, {
                     varTypeAnnotation: true,
                     allowFinal: isFinalAllowedForAssignmentTarget(target.d.valueExpr),
                     allowClassVar: 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'));
-                if (!isBareFinalOrClassVar) {
-                    const isTypeAliasAnnotation = (0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias');
-                    if (!isTypeAliasAnnotation) {
-                        if (assignType(annotationType, typeResult.type)) {
-                            // Don't attempt to narrow based on the annotated type if the type
-                            // is a enum because the annotated type in an enum doesn't reflect
-                            // the type of the symbol.
-                            if (!(0, types_1.isClassInstance)(typeResult.type) || !types_1.ClassType.isEnumClass(typeResult.type)) {
-                                typeResult = narrowTypeBasedOnAssignment(annotationType, typeResult);
-                            }
-                        }
-                    }
-                }
                 assignTypeToExpression(target.d.valueExpr, typeResult, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
                 break;
             }
@@ -4796,16 +4776,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const variadicIndex = typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
         // Is there a *tuple[T, ...] somewhere in the type arguments that we can expand if needed?
         let srcUnboundedTupleType;
-        let srcUnboundedTupleIndex = typeArgs.findIndex((arg) => {
-            if ((0, types_1.isUnpackedClass)(arg.type) &&
-                arg.type.priv.tupleTypeArgs &&
-                arg.type.priv.tupleTypeArgs.length === 1 &&
-                arg.type.priv.tupleTypeArgs[0].isUnbounded) {
-                srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
-                return true;
+        const findUnboundedTupleIndex = (startArgIndex) => {
+            return typeArgs.findIndex((arg, index) => {
+                if (index < startArgIndex) {
+                    return false;
+                }
+                if ((0, types_1.isUnpackedClass)(arg.type) &&
+                    arg.type.priv.tupleTypeArgs &&
+                    arg.type.priv.tupleTypeArgs.length === 1 &&
+                    arg.type.priv.tupleTypeArgs[0].isUnbounded) {
+                    srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
+                    return true;
+                }
+                return false;
+            });
+        };
+        let srcUnboundedTupleIndex = findUnboundedTupleIndex(0);
+        // Allow only one unpacked tuple that maps to a TypeVarTuple.
+        if (srcUnboundedTupleIndex >= 0) {
+            const secondUnboundedTupleIndex = findUnboundedTupleIndex(srcUnboundedTupleIndex + 1);
+            if (secondUnboundedTupleIndex >= 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), typeArgs[secondUnboundedTupleIndex].node);
             }
-            return false;
-        });
+        }
         if (srcUnboundedTupleType &&
             srcUnboundedTupleIndex >= 0 &&
             variadicIndex >= 0 &&
@@ -11334,7 +11327,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node);
                     }
                     else if (paramLimit === undefined && (0, types_1.isUnpackedClass)(typeArg.type)) {
-                        if (typeArg.type.priv.tupleTypeArgs?.some((typeArg) => (0, types_1.isTypeVarTuple)(typeArg.type) || typeArg.isUnbounded)) {
+                        if ((0, typeUtils_1.isUnboundedTupleClass)(typeArg.type)) {
                             noteSawUnpacked(typeArg);
                         }
                         validateTypeArg(typeArg, { allowUnpackedTuples: true });
@@ -17805,13 +17798,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Determine if the metaclass can be assigned to the object.
                 const metaclass = concreteSrcType.shared.effectiveMetaclass;
                 if (metaclass) {
-                    if ((0, types_1.isAnyOrUnknown)(metaclass)) {
-                        return true;
-                    }
-                    if (assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, 
-                    /* diag */ undefined, constraints, flags, recursionCount, 
-                    /* reportErrorsUsingObjType */ true)) {
-                        return true;
+                    if (!(0, types_1.isAnyOrUnknown)(metaclass)) {
+                        if (assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, 
+                        /* diag */ undefined, constraints, flags, recursionCount, 
+                        /* reportErrorsUsingObjType */ true)) {
+                            return true;
+                        }
                     }
                 }
             }