[ty] Understand classes that inherited from subscripted Protocol[] as generic

AlexWaygood · AlexWaygood · commit 1a25e14b91d8 · 2025-05-05T14:12:32.000+01:00
diff --git a/crates/ty_python_semantic/resources/mdtest/annotations/invalid.md b/crates/ty_python_semantic/resources/mdtest/annotations/invalid.md
@@ -99,6 +99,8 @@ async def outer():  # avoid unrelated syntax errors on yield, yield from, and aw
 def _(
     a: {1: 2},  # error: [invalid-type-form] "Dict literals are not allowed in type expressions"
     b: {1, 2},  # error: [invalid-type-form] "Set literals are not allowed in type expressions"
+    # TODO: the `[not-iterable]` error here is a false positive
+    # error: [not-iterable] "Object of type `_T` is not iterable"
     c: {k: v for k, v in [(1, 2)]},  # error: [invalid-type-form] "Dict comprehensions are not allowed in type expressions"
     d: [k for k in [1, 2]],  # error: [invalid-type-form] "List comprehensions are not allowed in type expressions"
     e: {k for k in [1, 2]},  # error: [invalid-type-form] "Set comprehensions are not allowed in type expressions"
diff --git a/crates/ty_python_semantic/resources/mdtest/annotations/starred.md b/crates/ty_python_semantic/resources/mdtest/annotations/starred.md
@@ -14,7 +14,7 @@ Ts = TypeVarTuple("Ts")
 
 def append_int(*args: *Ts) -> tuple[*Ts, int]:
     # TODO: tuple[*Ts]
-    reveal_type(args)  # revealed: tuple
+    reveal_type(args)  # revealed: tuple[Unknown, ...]
 
     return (*args, 1)
 
diff --git a/crates/ty_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md b/crates/ty_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md
@@ -30,19 +30,17 @@ def f(
     ordered_dict_bare: typing.OrderedDict,
     ordered_dict_parametrized: typing.OrderedDict[int, str],
 ):
-    # TODO: revealed: list[Unknown]
-    reveal_type(list_bare)  # revealed: list
+    reveal_type(list_bare)  # revealed: list[Unknown]
     # TODO: revealed: list[int]
-    reveal_type(list_parametrized)  # revealed: list
+    reveal_type(list_parametrized)  # revealed: list[Unknown]
 
     reveal_type(dict_bare)  # revealed: dict[Unknown, Unknown]
     # TODO: revealed: dict[int, str]
     reveal_type(dict_parametrized)  # revealed: dict[Unknown, Unknown]
 
-    # TODO: revealed: set[Unknown]
-    reveal_type(set_bare)  # revealed: set
+    reveal_type(set_bare)  # revealed: set[Unknown]
     # TODO: revealed: set[int]
-    reveal_type(set_parametrized)  # revealed: set
+    reveal_type(set_parametrized)  # revealed: set[Unknown]
 
     # TODO: revealed: frozenset[Unknown]
     reveal_type(frozen_set_bare)  # revealed: frozenset
@@ -61,10 +59,9 @@ def f(
     # TODO: revealed: defaultdict[str, int]
     reveal_type(default_dict_parametrized)  # revealed: defaultdict[Unknown, Unknown]
 
-    # TODO: revealed: deque[Unknown]
-    reveal_type(deque_bare)  # revealed: deque
+    reveal_type(deque_bare)  # revealed: deque[Unknown]
     # TODO: revealed: deque[str]
-    reveal_type(deque_parametrized)  # revealed: deque
+    reveal_type(deque_parametrized)  # revealed: deque[Unknown]
 
     reveal_type(ordered_dict_bare)  # revealed: OrderedDict[Unknown, Unknown]
     # TODO: revealed: OrderedDict[int, str]
@@ -84,20 +81,18 @@ import typing
 
 class ListSubclass(typing.List): ...
 
-# TODO: generic protocols
-# revealed: tuple[Literal[ListSubclass], Literal[list], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, Literal[object]]
+# revealed: tuple[Literal[ListSubclass], Literal[list[Unknown]], Literal[MutableSequence[_T]], Literal[Sequence[_T]], Literal[Reversible[_T_co]], Literal[Collection[_T_co]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], Literal[object]]
 reveal_type(ListSubclass.__mro__)
 
 class DictSubclass(typing.Dict): ...
 
-# TODO: generic protocols
-# revealed: tuple[Literal[DictSubclass], Literal[dict[Unknown, Unknown]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, typing.Generic[_KT, _VT_co], Literal[object]]
+# TODO: should not have `Generic` multiple times
+# revealed: tuple[Literal[DictSubclass], Literal[dict[Unknown, Unknown]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection[_KT]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], typing.Generic[_KT, _VT_co], Literal[object]]
 reveal_type(DictSubclass.__mro__)
 
 class SetSubclass(typing.Set): ...
 
-# TODO: generic protocols
-# revealed: tuple[Literal[SetSubclass], Literal[set], Literal[MutableSet], Literal[AbstractSet], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, Literal[object]]
+# revealed: tuple[Literal[SetSubclass], Literal[set[Unknown]], Literal[MutableSet[_T]], Literal[AbstractSet[_T]], Literal[Collection[_T_co]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], Literal[object]]
 reveal_type(SetSubclass.__mro__)
 
 class FrozenSetSubclass(typing.FrozenSet): ...
@@ -112,31 +107,30 @@ reveal_type(FrozenSetSubclass.__mro__)
 
 class ChainMapSubclass(typing.ChainMap): ...
 
-# TODO: generic protocols
-# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap[Unknown, Unknown]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, typing.Generic[_KT, _VT_co], Literal[object]]
+# TODO: should not have `Generic` multiple times
+# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap[Unknown, Unknown]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection[_KT]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], typing.Generic[_KT, _VT_co], Literal[object]]
 reveal_type(ChainMapSubclass.__mro__)
 
 class CounterSubclass(typing.Counter): ...
 
-# TODO: Should be (CounterSubclass, Counter, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[CounterSubclass], Literal[Counter[Unknown]], Literal[dict[_T, int]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, typing.Generic[_KT, _VT_co], typing.Generic[_T], Literal[object]]
+# TODO: Should not have `Generic` multiple times
+# revealed: tuple[Literal[CounterSubclass], Literal[Counter[Unknown]], Literal[dict[_T, int]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection[_KT]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], typing.Generic[_KT, _VT_co], typing.Generic[_T], Literal[object]]
 reveal_type(CounterSubclass.__mro__)
 
 class DefaultDictSubclass(typing.DefaultDict): ...
 
-# TODO: Should be (DefaultDictSubclass, defaultdict, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[DefaultDictSubclass], Literal[defaultdict[Unknown, Unknown]], Literal[dict[_KT, _VT]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, typing.Generic[_KT, _VT_co], Literal[object]]
+# TODO: Should not have `Generic` multiple times
+# revealed: tuple[Literal[DefaultDictSubclass], Literal[defaultdict[Unknown, Unknown]], Literal[dict[_KT, _VT]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection[_KT]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], typing.Generic[_KT, _VT_co], Literal[object]]
 reveal_type(DefaultDictSubclass.__mro__)
 
 class DequeSubclass(typing.Deque): ...
 
-# TODO: generic protocols
-# revealed: tuple[Literal[DequeSubclass], Literal[deque], Literal[MutableSequence], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, Literal[object]]
+# revealed: tuple[Literal[DequeSubclass], Literal[deque[Unknown]], Literal[MutableSequence[_T]], Literal[Sequence[_T]], Literal[Reversible[_T_co]], Literal[Collection[_T_co]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], Literal[object]]
 reveal_type(DequeSubclass.__mro__)
 
 class OrderedDictSubclass(typing.OrderedDict): ...
 
-# TODO: Should be (OrderedDictSubclass, OrderedDict, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
-# revealed: tuple[Literal[OrderedDictSubclass], Literal[OrderedDict[Unknown, Unknown]], Literal[dict[_KT, _VT]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, typing.Generic[_KT, _VT_co], Literal[object]]
+# TODO: Should not have multiple `Generic` bases
+# revealed: tuple[Literal[OrderedDictSubclass], Literal[OrderedDict[Unknown, Unknown]], Literal[dict[_KT, _VT]], Literal[MutableMapping[_KT, _VT]], Literal[Mapping[_KT, _VT]], Literal[Collection[_KT]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], typing.Generic[_KT, _VT_co], Literal[object]]
 reveal_type(OrderedDictSubclass.__mro__)
 ```
diff --git a/crates/ty_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md b/crates/ty_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md
@@ -16,15 +16,15 @@ Alias: TypeAlias = int
 
 def f(*args: Unpack[Ts]) -> tuple[Unpack[Ts]]:
     # TODO: should understand the annotation
-    reveal_type(args)  # revealed: tuple
+    reveal_type(args)  # revealed: tuple[Unknown, ...]
 
     reveal_type(Alias)  # revealed: @Todo(Support for `typing.TypeAlias`)
 
 def g() -> TypeGuard[int]: ...
 def h() -> TypeIs[int]: ...
 def i(callback: Callable[Concatenate[int, P], R_co], *args: P.args, **kwargs: P.kwargs) -> R_co:
     # TODO: should understand the annotation
-    reveal_type(args)  # revealed: tuple
+    reveal_type(args)  # revealed: tuple[Unknown, ...]
     reveal_type(kwargs)  # revealed: dict[str, @Todo(Support for `typing.ParamSpec`)]
     return callback(42, *args, **kwargs)
 
diff --git a/crates/ty_python_semantic/resources/mdtest/assignment/annotations.md b/crates/ty_python_semantic/resources/mdtest/assignment/annotations.md
@@ -61,7 +61,7 @@ reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
 reveal_type(e)  # revealed: @Todo(full tuple[...] support)
 reveal_type(f)  # revealed: @Todo(full tuple[...] support)
 reveal_type(g)  # revealed: @Todo(full tuple[...] support)
-reveal_type(h)  # revealed: tuple[@Todo(specialized non-generic class), @Todo(specialized non-generic class)]
+reveal_type(h)  # revealed: tuple[list[int], list[int]]
 
 reveal_type(i)  # revealed: tuple[str | int, str | int]
 reveal_type(j)  # revealed: tuple[str | int]
@@ -76,7 +76,7 @@ a: tuple[()] = (1, 2)
 # error: [invalid-assignment] "Object of type `tuple[Literal["foo"]]` is not assignable to `tuple[int]`"
 b: tuple[int] = ("foo",)
 
-# error: [invalid-assignment] "Object of type `tuple[list, Literal["foo"]]` is not assignable to `tuple[str | int, str]`"
+# error: [invalid-assignment] "Object of type `tuple[list[Unknown], Literal["foo"]]` is not assignable to `tuple[str | int, str]`"
 c: tuple[str | int, str] = ([], "foo")
 ```
 
diff --git a/crates/ty_python_semantic/resources/mdtest/attributes.md b/crates/ty_python_semantic/resources/mdtest/attributes.md
@@ -1728,7 +1728,7 @@ reveal_type(False.real)  # revealed: Literal[0]
 All attribute access on literal `bytes` types is currently delegated to `builtins.bytes`:
 
 ```py
-# revealed: bound method Literal[b"foo"].join(iterable_of_bytes: @Todo(specialized non-generic class), /) -> bytes
+# revealed: bound method Literal[b"foo"].join(iterable_of_bytes: Iterable[@Todo(Support for `typing.TypeAlias`)], /) -> bytes
 reveal_type(b"foo".join)
 # revealed: bound method Literal[b"foo"].endswith(suffix: @Todo(Support for `typing.TypeAlias`), start: SupportsIndex | None = ellipsis, end: SupportsIndex | None = ellipsis, /) -> bool
 reveal_type(b"foo".endswith)
diff --git a/crates/ty_python_semantic/resources/mdtest/expression/lambda.md b/crates/ty_python_semantic/resources/mdtest/expression/lambda.md
@@ -79,8 +79,7 @@ lambda x=1: reveal_type(x)  # revealed: Unknown | Literal[1]
 Using a variadic parameter:
 
 ```py
-# TODO: should be `tuple[Unknown, ...]` (needs generics)
-lambda *args: reveal_type(args)  # revealed: tuple
+lambda *args: reveal_type(args)  # revealed: tuple[Unknown, ...]
 ```
 
 Using a keyword-variadic parameter:
diff --git a/crates/ty_python_semantic/resources/mdtest/function/parameters.md b/crates/ty_python_semantic/resources/mdtest/function/parameters.md
@@ -25,8 +25,8 @@ def f(a, b: int, c=1, d: int = 2, /, e=3, f: Literal[4] = 4, *args: object, g=5,
     reveal_type(f)  # revealed: Literal[4]
     reveal_type(g)  # revealed: Unknown | Literal[5]
     reveal_type(h)  # revealed: Literal[6]
-    # TODO: should be `tuple[object, ...]` (needs generics)
-    reveal_type(args)  # revealed: tuple
+    # TODO: should be `tuple[object, ...]`
+    reveal_type(args)  # revealed: tuple[Unknown, ...]
     reveal_type(kwargs)  # revealed: dict[str, str]
 ```
 
@@ -36,8 +36,7 @@ def f(a, b: int, c=1, d: int = 2, /, e=3, f: Literal[4] = 4, *args: object, g=5,
 
 ```py
 def g(*args, **kwargs):
-    # TODO: should be `tuple[Unknown, ...]` (needs generics)
-    reveal_type(args)  # revealed: tuple
+    reveal_type(args)  # revealed: tuple[Unknown, ...]
     reveal_type(kwargs)  # revealed: dict[str, Unknown]
 ```
 
diff --git a/crates/ty_python_semantic/resources/mdtest/generics/legacy/variables.md b/crates/ty_python_semantic/resources/mdtest/generics/legacy/variables.md
@@ -38,6 +38,7 @@ T = TypeVar("T")
 U: TypeVar = TypeVar("U")
 
 # error: [invalid-legacy-type-variable] "A legacy `typing.TypeVar` must be immediately assigned to a variable"
+# error: [invalid-type-form] "Function calls are not allowed in type expressions"
 TestList = list[TypeVar("W")]
 ```
 
diff --git a/crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md b/crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md
@@ -65,7 +65,7 @@ from typing import Generic, TypeVar
 
 T = TypeVar("T")
 
-# error: [invalid-generic-class] "Cannot both inherit from `Generic` and use PEP 695 type variables"
+# error: [invalid-generic-class] "Cannot both inherit from `typing.Generic` and use PEP 695 type variables"
 class BothGenericSyntaxes[U](Generic[T]): ...
 ```
 
diff --git a/crates/ty_python_semantic/resources/mdtest/literal/collections/list.md b/crates/ty_python_semantic/resources/mdtest/literal/collections/list.md
@@ -3,5 +3,5 @@
 ## Empty list
 
 ```py
-reveal_type([])  # revealed: list
+reveal_type([])  # revealed: list[Unknown]
 ```
diff --git a/crates/ty_python_semantic/resources/mdtest/literal/collections/set.md b/crates/ty_python_semantic/resources/mdtest/literal/collections/set.md
@@ -3,5 +3,5 @@
 ## Basic set
 
 ```py
-reveal_type({1, 2})  # revealed: set
+reveal_type({1, 2})  # revealed: set[Unknown]
 ```
diff --git a/crates/ty_python_semantic/resources/mdtest/named_tuple.md b/crates/ty_python_semantic/resources/mdtest/named_tuple.md
@@ -48,8 +48,8 @@ alice2 = Person2(1, "Alice")
 # TODO: should be an error
 Person2(1)
 
-reveal_type(alice2.id)  # revealed: @Todo(GenericAlias instance)
-reveal_type(alice2.name)  # revealed: @Todo(GenericAlias instance)
+reveal_type(alice2.id)  # revealed: @Todo(functional `NamedTuple` syntax)
+reveal_type(alice2.name)  # revealed: @Todo(functional `NamedTuple` syntax)
 ```
 
 ### Multiple Inheritance
diff --git a/crates/ty_python_semantic/resources/mdtest/narrow/match.md b/crates/ty_python_semantic/resources/mdtest/narrow/match.md
@@ -133,11 +133,11 @@ match x:
     case "foo" | 42 | None:
         reveal_type(x)  # revealed: Literal["foo", 42] | None
     case "foo" | tuple():
-        reveal_type(x)  # revealed: tuple
+        reveal_type(x)  # revealed: tuple[Unknown, ...]
     case True | False:
         reveal_type(x)  # revealed: bool
     case 3.14 | 2.718 | 1.414:
-        reveal_type(x)  # revealed: float & ~tuple
+        reveal_type(x)  # revealed: float & ~tuple[Unknown, ...]
 
 reveal_type(x)  # revealed: object
 ```
@@ -155,7 +155,7 @@ reveal_type(x)  # revealed: object
 match x:
     case "foo" | 42 | None if reveal_type(x):  # revealed: Literal["foo", 42] | None
         pass
-    case "foo" | tuple() if reveal_type(x):  # revealed: Literal["foo"] | tuple
+    case "foo" | tuple() if reveal_type(x):  # revealed: Literal["foo"] | tuple[Unknown, ...]
         pass
     case True | False if reveal_type(x):  # revealed: bool
         pass
diff --git a/crates/ty_python_semantic/resources/mdtest/protocols.md b/crates/ty_python_semantic/resources/mdtest/protocols.md
@@ -58,6 +58,7 @@ class Bar1(Protocol[T], Generic[T]):
 class Bar2[T](Protocol):
     x: T
 
+# error: [invalid-generic-class] "Cannot both inherit from subscripted `typing.Protocol` and use PEP 695 type variables"
 class Bar3[T](Protocol[T]):
     x: T
 ```
@@ -70,8 +71,8 @@ simultaneously:
 class DuplicateBases(Protocol, Protocol[T]):
     x: T
 
-# TODO: should not have `Protocol` multiple times
-# revealed: tuple[Literal[DuplicateBases], typing.Protocol, @Todo(`Protocol[]` subscript), typing.Generic, Literal[object]]
+# TODO: should not have `Protocol` or `Generic` multiple times
+# revealed: tuple[Literal[DuplicateBases[Unknown]], typing.Protocol, typing.Generic, typing.Protocol[T], typing.Generic[T], Literal[object]]
 reveal_type(DuplicateBases.__mro__)
 ```
 
diff --git a/crates/ty_python_semantic/resources/mdtest/scopes/moduletype_attrs.md b/crates/ty_python_semantic/resources/mdtest/scopes/moduletype_attrs.md
@@ -13,8 +13,7 @@ reveal_type(__loader__)  # revealed: LoaderProtocol | None
 reveal_type(__package__)  # revealed: str | None
 reveal_type(__doc__)  # revealed: str | None
 reveal_type(__spec__)  # revealed: ModuleSpec | None
-
-reveal_type(__path__)  # revealed: @Todo(specialized non-generic class)
+reveal_type(__path__)  # revealed: MutableSequence[str]
 
 class X:
     reveal_type(__name__)  # revealed: str
diff --git a/crates/ty_python_semantic/resources/mdtest/subscript/lists.md b/crates/ty_python_semantic/resources/mdtest/subscript/lists.md
@@ -9,13 +9,13 @@ A list can be indexed into with:
 
 ```py
 x = [1, 2, 3]
-reveal_type(x)  # revealed: list
+reveal_type(x)  # revealed: list[Unknown]
 
 # TODO reveal int
 reveal_type(x[0])  # revealed: Unknown
 
 # TODO reveal list
-reveal_type(x[0:1])  # revealed: @Todo(specialized non-generic class)
+reveal_type(x[0:1])  # revealed: list[_T]
 
 # error: [call-non-callable]
 reveal_type(x["a"])  # revealed: Unknown
diff --git a/crates/ty_python_semantic/resources/mdtest/subscript/tuple.md b/crates/ty_python_semantic/resources/mdtest/subscript/tuple.md
@@ -83,9 +83,9 @@ python-version = "3.9"
 ```py
 class A(tuple[int, str]): ...
 
-# Runtime value: `(A, tuple, object)`
-# TODO: Generics
-reveal_type(A.__mro__)  # revealed: tuple[Literal[A], @Todo(GenericAlias instance), Literal[object]]
+# TODO: the `tuple[@Todo(Generic tuple specializations), ...]` element should be `tuple[int, str]`
+# revealed: tuple[Literal[A], Literal[tuple[@Todo(Generic tuple specializations), ...]], Literal[Sequence[_T_co]], Literal[Reversible[_T_co]], Literal[Collection[_T_co]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], Literal[object]]
+reveal_type(A.__mro__)
 ```
 
 ## `typing.Tuple`
@@ -100,7 +100,7 @@ from typing import Any, Tuple
 class A: ...
 
 def _(c: Tuple, d: Tuple[int, A], e: Tuple[Any, ...]):
-    reveal_type(c)  # revealed: tuple
+    reveal_type(c)  # revealed: tuple[Unknown, ...]
     reveal_type(d)  # revealed: tuple[int, A]
     reveal_type(e)  # revealed: @Todo(full tuple[...] support)
 ```
@@ -115,7 +115,6 @@ from typing import Tuple
 
 class C(Tuple): ...
 
-# TODO: generic protocols
-# revealed: tuple[Literal[C], Literal[tuple], Literal[Sequence], Literal[Reversible], Literal[Collection], Literal[Iterable], Literal[Container], @Todo(`Protocol[]` subscript), typing.Generic, Literal[object]]
+# revealed: tuple[Literal[C], Literal[tuple[Unknown, ...]], Literal[Sequence[_T_co]], Literal[Reversible[_T_co]], Literal[Collection[_T_co]], Literal[Iterable[_T_co]], Literal[Container[_T_co]], typing.Protocol[_T_co], typing.Generic[_T_co], Literal[object]]
 reveal_type(C.__mro__)
 ```
diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs
@@ -3875,6 +3875,9 @@ impl<'db> Type<'db> {
                     );
                     Signatures::single(signature)
                 }
+                Some(KnownClass::NamedTuple) => {
+                    Signatures::single(CallableSignature::todo("functional `NamedTuple` syntax"))
+                }
                 Some(KnownClass::Object) => {
                     // ```py
                     // class object:
@@ -4262,6 +4265,12 @@ impl<'db> Type<'db> {
             return Ok(UnionType::from_elements(db, tuple_type.elements(db)));
         }
 
+        if let Type::GenericAlias(alias) = self {
+            if alias.origin(db).is_known(db, KnownClass::Tuple) {
+                return Ok(todo_type!("*tuple[] annotations"));
+            }
+        }
+
         let try_call_dunder_getitem = || {
             self.try_call_dunder(
                 db,
@@ -4728,7 +4737,7 @@ impl<'db> Type<'db> {
                 KnownInstanceType::TypeAlias => Ok(todo_type!("Support for `typing.TypeAlias`")),
                 KnownInstanceType::TypedDict => Ok(todo_type!("Support for `typing.TypedDict`")),
 
-                KnownInstanceType::Protocol => Err(InvalidTypeExpressionError {
+                KnownInstanceType::Protocol(_) => Err(InvalidTypeExpressionError {
                     invalid_expressions: smallvec::smallvec![InvalidTypeExpression::Protocol],
                     fallback_type: Type::unknown(),
                 }),
diff --git a/crates/ty_python_semantic/src/types/class.rs b/crates/ty_python_semantic/src/types/class.rs
diff --git a/crates/ty_python_semantic/src/types/class_base.rs b/crates/ty_python_semantic/src/types/class_base.rs
diff --git a/crates/ty_python_semantic/src/types/display.rs b/crates/ty_python_semantic/src/types/display.rs
diff --git a/crates/ty_python_semantic/src/types/generics.rs b/crates/ty_python_semantic/src/types/generics.rs
diff --git a/crates/ty_python_semantic/src/types/infer.rs b/crates/ty_python_semantic/src/types/infer.rs
diff --git a/crates/ty_python_semantic/src/types/known_instance.rs b/crates/ty_python_semantic/src/types/known_instance.rs
diff --git a/crates/ty_python_semantic/src/types/type_ordering.rs b/crates/ty_python_semantic/src/types/type_ordering.rs
