Add TupleGetterType type

Gatsik · Gatsik · commit 9cedc4fc252e · 2025-07-19T03:37:20.000+03:00
diff --git a/mypy/checkmember.py b/mypy/checkmember.py
@@ -61,6 +61,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypedDictType,
@@ -935,12 +936,20 @@ def analyze_var(
     return result
 
 
+def expand_tuplegetter_type_if_needed(typ: Type) -> Type:
+    proper = get_proper_type(typ)
+    if isinstance(proper, TupleGetterType):
+        return proper.typ
+    return typ
+
+
 def expand_without_binding(
     typ: Type, var: Var, itype: Instance, original_itype: Instance, mx: MemberContext
 ) -> Type:
     if not mx.preserve_type_var_ids:
         typ = freshen_all_functions_type_vars(typ)
     typ = expand_self_type_if_needed(typ, mx, var, original_itype)
+    typ = expand_tuplegetter_type_if_needed(typ)
     expanded = expand_type_by_instance(typ, itype)
     freeze_all_type_vars(expanded)
     return expanded
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -36,6 +36,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -1244,6 +1245,9 @@ def infer_against_overloaded(
         item = find_matching_overload_item(overloaded, template)
         return infer_constraints(template, item, self.direction)
 
+    def visit_tuplegetter_type(self, template: TupleGetterType) -> list[Constraint]:
+        raise NotImplementedError
+
     def visit_tuple_type(self, template: TupleType) -> list[Constraint]:
         actual = self.actual
         unpack_index = find_unpack_in_list(template.items)
diff --git a/mypy/copytype.py b/mypy/copytype.py
@@ -15,6 +15,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     TypeAliasType,
     TypedDictType,
@@ -103,6 +104,9 @@ def visit_partial_type(self, t: PartialType) -> ProperType:
     def visit_callable_type(self, t: CallableType) -> ProperType:
         return self.copy_common(t, t.copy_modified())
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> ProperType:
+        return self.copy_common(t, TupleGetterType(t.typ))
+
     def visit_tuple_type(self, t: TupleType) -> ProperType:
         return self.copy_common(t, TupleType(t.items, t.partial_fallback, implicit=t.implicit))
 
diff --git a/mypy/erasetype.py b/mypy/erasetype.py
@@ -17,6 +17,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -115,6 +116,9 @@ def visit_callable_type(self, t: CallableType) -> ProperType:
     def visit_overloaded(self, t: Overloaded) -> ProperType:
         return t.fallback.accept(self)
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> ProperType:
+        raise NotImplementedError
+
     def visit_tuple_type(self, t: TupleType) -> ProperType:
         return t.partial_fallback.accept(self)
 
diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -23,6 +23,7 @@
     PartialType,
     ProperType,
     TrivialSyntheticTypeTranslator,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -456,6 +457,9 @@ def expand_type_tuple_with_unpack(self, typs: tuple[Type, ...]) -> list[Type]:
                 items.append(item.accept(self))
         return items
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> Type:
+        return TupleGetterType(t.typ.accept(self))
+
     def visit_tuple_type(self, t: TupleType) -> Type:
         items = self.expand_type_list_with_unpack(t.items)
         if len(items) == 1:
diff --git a/mypy/fixup.py b/mypy/fixup.py
@@ -29,6 +29,7 @@
     Overloaded,
     Parameters,
     ParamSpecType,
+    TupleGetterType,
     TupleType,
     TypeAliasType,
     TypedDictType,
@@ -296,6 +297,9 @@ def visit_uninhabited_type(self, o: Any) -> None:
     def visit_partial_type(self, o: Any) -> None:
         raise RuntimeError("Shouldn't get here", o)
 
+    def visit_tuplegetter_type(self, tgt: TupleGetterType) -> None:
+        tgt.typ.accept(self)
+
     def visit_tuple_type(self, tt: TupleType) -> None:
         if tt.items:
             for it in tt.items:
diff --git a/mypy/indirection.py b/mypy/indirection.py
@@ -128,6 +128,9 @@ def visit_overloaded(self, t: types.Overloaded) -> None:
         self._visit_type_list(list(t.items))
         self._visit(t.fallback)
 
+    def visit_tuplegetter_type(self, t: types.TupleGetterType) -> None:
+        self._visit(t.typ)
+
     def visit_tuple_type(self, t: types.TupleType) -> None:
         self._visit_type_list(t.items)
         self._visit(t.partial_fallback)
diff --git a/mypy/join.py b/mypy/join.py
@@ -32,6 +32,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -559,6 +560,9 @@ def join_tuples(self, s: TupleType, t: TupleType) -> list[Type] | None:
                 items.append(join_types(fi, vi))
         return items
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> ProperType:
+        raise NotImplementedError
+
     def visit_tuple_type(self, t: TupleType) -> ProperType:
         # When given two fixed-length tuples:
         # * If they have the same length, join their subtypes item-wise:
diff --git a/mypy/meet.py b/mypy/meet.py
@@ -32,6 +32,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -1039,6 +1040,9 @@ def meet_tuples(self, s: TupleType, t: TupleType) -> list[Type] | None:
                 items.append(self.meet(fi, vi))
         return items
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> ProperType:
+        raise NotImplementedError
+
     def visit_tuple_type(self, t: TupleType) -> ProperType:
         if isinstance(self.s, TupleType):
             items = self.meet_tuples(self.s, t)
diff --git a/mypy/messages.py b/mypy/messages.py
@@ -84,6 +84,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -2664,6 +2665,8 @@ def format_literal_value(typ: LiteralType) -> str:
         else:
             # TODO: better disambiguate ParamSpec name clashes.
             return typ.name_with_suffix()
+    elif isinstance(typ, TupleGetterType):
+        return f"TupleGetterType[{typ.typ}]"
     elif isinstance(typ, TupleType):
         # Prefer the name of the fallback class (if not tuple), as it's more informative.
         if typ.partial_fallback.type.fullname != "builtins.tuple":
diff --git a/mypy/semanal_namedtuple.py b/mypy/semanal_namedtuple.py
@@ -59,6 +59,7 @@
     AnyType,
     CallableType,
     LiteralType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeOfAny,
@@ -552,7 +553,7 @@ def add_field(
             var._fullname = f"{info.fullname}.{var.name}"
             info.names[var.name] = SymbolTableNode(MDEF, var)
 
-        fields = [Var(item, typ) for item, typ in zip(items, types)]
+        fields = [Var(item, TupleGetterType(typ)) for item, typ in zip(items, types)]
         for var in fields:
             add_field(var, is_property=True)
         # We can't share Vars between fields and method arguments, since they
diff --git a/mypy/semanal_typeargs.py b/mypy/semanal_typeargs.py
@@ -25,6 +25,7 @@
     Instance,
     Parameters,
     ParamSpecType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -103,6 +104,9 @@ def visit_type_alias_type(self, t: TypeAliasType) -> None:
             # the expansion, most likely it will result in the same kind of error.
             get_proper_type(t).accept(self)
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> None:
+        raise NotImplementedError
+
     def visit_tuple_type(self, t: TupleType) -> None:
         t.items = flatten_nested_tuples(t.items)
         # We could also normalize Tuple[*tuple[X, ...]] -> tuple[X, ...] like in
diff --git a/mypy/server/astdiff.py b/mypy/server/astdiff.py
@@ -88,6 +88,7 @@ class level -- these are handled at attribute level (say, 'mod.Cls.method'
     Parameters,
     ParamSpecType,
     PartialType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -481,6 +482,9 @@ def normalize_callable_variables(self, typ: CallableType) -> CallableType:
         with state.strict_optional_set(True):
             return expand_type(typ, tvmap).copy_modified(variables=tvs)
 
+    def visit_tuplegetter_type(self, typ: TupleGetterType) -> SnapshotItem:
+        return ("TupleGetterType", snapshot_type(typ.typ))
+
     def visit_tuple_type(self, typ: TupleType) -> SnapshotItem:
         return ("TupleType", snapshot_types(typ.items))
 
diff --git a/mypy/server/astmerge.py b/mypy/server/astmerge.py
@@ -96,6 +96,7 @@
     PlaceholderType,
     RawExpressionType,
     SyntheticTypeVisitor,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -470,6 +471,9 @@ def visit_deleted_type(self, typ: DeletedType) -> None:
     def visit_partial_type(self, typ: PartialType) -> None:
         raise RuntimeError("Cannot handle partial type")
 
+    def visit_tuplegetter_type(self, typ: TupleGetterType) -> None:
+        typ.typ.accept(self)
+
     def visit_tuple_type(self, typ: TupleType) -> None:
         for item in typ.items:
             item.accept(self)
diff --git a/mypy/server/deps.py b/mypy/server/deps.py
@@ -157,6 +157,7 @@ class 'mod.Cls'. This can also refer to an attribute inherited from a
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -1017,6 +1018,9 @@ def visit_deleted_type(self, typ: DeletedType) -> list[str]:
     def visit_partial_type(self, typ: PartialType) -> list[str]:
         assert False, "Should not see a partial type here"
 
+    def visit_tuplegetter_type(self, typ: TupleGetterType) -> list[str]:
+        return typ.typ.accept(self)
+
     def visit_tuple_type(self, typ: TupleType) -> list[str]:
         triggers = []
         for item in typ.items:
diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -55,6 +55,7 @@
     ParamSpecType,
     PartialType,
     ProperType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -759,6 +760,14 @@ def visit_callable_type(self, left: CallableType) -> bool:
         else:
             return False
 
+    def visit_tuplegetter_type(self, left: TupleGetterType) -> bool:
+        right = self.right
+        if isinstance(right, TupleGetterType):
+            return left.typ == right.typ
+        elif isinstance(right, Instance):
+            return self.is_top_type(right)
+        return False
+
     def visit_tuple_type(self, left: TupleType) -> bool:
         right = self.right
         if isinstance(right, Instance):
diff --git a/mypy/type_visitor.py b/mypy/type_visitor.py
@@ -35,6 +35,7 @@
     PartialType,
     PlaceholderType,
     RawExpressionType,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -114,6 +115,10 @@ def visit_callable_type(self, t: CallableType, /) -> T:
     def visit_overloaded(self, t: Overloaded, /) -> T:
         pass
 
+    @abstractmethod
+    def visit_tuplegetter_type(self, t: TupleGetterType, /) -> T:
+        pass
+
     @abstractmethod
     def visit_tuple_type(self, t: TupleType, /) -> T:
         pass
@@ -260,6 +265,9 @@ def visit_callable_type(self, t: CallableType, /) -> Type:
             variables=self.translate_variables(t.variables),
         )
 
+    def visit_tuplegetter_type(self, t: TupleGetterType, /) -> Type:
+        return TupleGetterType(t.typ.accept(self))
+
     def visit_tuple_type(self, t: TupleType, /) -> Type:
         return TupleType(
             self.translate_types(t.items),
@@ -412,6 +420,9 @@ def visit_callable_type(self, t: CallableType, /) -> T:
     def visit_tuple_type(self, t: TupleType, /) -> T:
         return self.query_types([t.partial_fallback] + t.items)
 
+    def visit_tuplegetter_type(self, t: TupleGetterType, /) -> T:
+        return self.query_types([t.typ])
+
     def visit_typeddict_type(self, t: TypedDictType, /) -> T:
         return self.query_types(t.items.values())
 
@@ -549,6 +560,9 @@ def visit_callable_type(self, t: CallableType, /) -> bool:
         else:
             return args and ret
 
+    def visit_tuplegetter_type(self, t: TupleGetterType, /) -> bool:
+        return self.default
+
     def visit_tuple_type(self, t: TupleType, /) -> bool:
         return self.query_types([t.partial_fallback] + t.items)
 
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -92,6 +92,7 @@
     RequiredType,
     SyntheticTypeVisitor,
     TrivialSyntheticTypeTranslator,
+    TupleGetterType,
     TupleType,
     Type,
     TypeAliasType,
@@ -1261,6 +1262,9 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         # fine to just return it as-is.
         return t
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> Type:
+        raise NotImplementedError
+
     def visit_tuple_type(self, t: TupleType) -> Type:
         # Types such as (t1, t2, ...) only allowed in assignment statements. They'll
         # generate errors elsewhere, and Tuple[t1, t2, ...] must be used instead.
@@ -2637,6 +2641,9 @@ def visit_callable_type(self, t: CallableType) -> None:
         self.process_types(t.arg_types)
         t.ret_type.accept(self)
 
+    def visit_tuplegetter_type(self, t: TupleGetterType) -> None:
+        raise NotImplementedError
+
     def visit_tuple_type(self, t: TupleType) -> None:
         self.process_types(t.items)
 
diff --git a/mypy/types.py b/mypy/types.py
diff --git a/mypy/typetraverser.py b/mypy/typetraverser.py
diff --git a/test-data/unit/check-class-namedtuple.test b/test-data/unit/check-class-namedtuple.test
diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test
diff --git a/test-data/unit/merge.test b/test-data/unit/merge.test
