Fix recognition of several typing special forms, including: Optional, Union, Callable

Author: davidfstr

mypy/semanal.py

@@ -7843,7 +7843,8 @@ def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> None:
                     return
         elif isinstance(maybe_type_expr, IndexExpr):
             if isinstance(maybe_type_expr.base, NameExpr):
-                if isinstance(maybe_type_expr.base.node, Var):
+                if (isinstance(maybe_type_expr.base.node, Var) and
+                        not self.var_is_typing_special_form(maybe_type_expr.base)):
                     # Leftmost part of IndexExpr refers to a Var. Not a valid type.
                     maybe_type_expr.as_type = None
                     return
@@ -7855,7 +7856,8 @@ def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> None:
                         break
                     next_leftmost = leftmost
                 if isinstance(leftmost, NameExpr):
-                    if isinstance(leftmost.node, Var):
+                    if (isinstance(leftmost.node, Var) and
+                            not self.var_is_typing_special_form(leftmost.node)):
                         # Leftmost part of IndexExpr refers to a Var. Not a valid type.
                         maybe_type_expr.as_type = None
                         return
@@ -7903,6 +7905,21 @@ def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> None:
 
         maybe_type_expr.as_type = t
 
+    @staticmethod
+    def var_is_typing_special_form(var: Var) -> bool:
+        return (
+            var.fullname.startswith('typing') and
+            var.fullname in [
+                'typing.Annotated', 'typing_extensions.Annotated',
+                'typing.Callable',
+                'typing.Literal', 'typing_extensions.Literal',
+                'typing.Optional',
+                'typing.TypeGuard', 'typing_extensions.TypeGuard',
+                'typing.TypeIs', 'typing_extensions.TypeIs',
+                'typing.Union',
+            ]
+        )
+
     @contextmanager
     def isolated_error_analysis(self) -> Iterator[None]:
         """

test-data/unit/check-typeform.test

@@ -683,6 +683,103 @@ else:
 [typing fixtures/typing-full.pyi]
 
 
+-- Type Expressions Assignable To TypeForm Variable
+
+[case testEveryKindOfTypeExpressionIsAssignableToATypeFormVariable]
+# flags: --python-version 3.14 --enable-incomplete-feature=TypeForm
+# NOTE: Importing Callable from collections.abc also works OK
+from typing import (
+    Any, Callable, Dict, List, Literal, LiteralString, NoReturn,
+    Optional, ParamSpec, Self, Type, TypeGuard, TypeVar, Union,
+)
+from typing_extensions import (
+    Annotated, Concatenate, Never, TypeAlias, TypeForm, TypeIs,
+)
+#
+class SomeClass:
+    pass
+SomeTypeAlias: TypeAlias = SomeClass
+SomeTypeVar = TypeVar('SomeTypeVar')
+type IntTuple[*Ts] = tuple[int, *Ts]
+P = ParamSpec('P')
+R = TypeVar('R')
+#
+typx: TypeForm
+# Begin rules taken from: https://typing.python.org/en/latest/spec/annotations.html#grammar-token-expression-grammar-type_expression
+# <Any>
+typx = Any
+class SelfBinder:
+    def bind_self(self) -> Self:
+        typx: TypeForm
+        # <Self> (valid only in some contexts)
+        typx = Self
+        return self
+# <LiteralString>
+typx = LiteralString
+# <NoReturn>
+typx = NoReturn
+# <Never>
+typx = Never
+# <None>
+typx = None
+# name (where name must refer to a valid in-scope class)
+typx = SomeClass
+# name (where name must refer to a valid in-scope type alias)
+typx = SomeTypeAlias
+# name (where name must refer to a valid in-scope TypeVar)
+# NOTE: Unbound TypeVar isn't currently accepted as a TypeForm. Is that OK?
+typx = SomeTypeVar  # E: Incompatible types in assignment (expression has type "TypeVar", variable has type "TypeForm[Any]")
+# name '[' type_expression (',' type_expression)* ']'
+typx = Dict[str, int]
+# (TODO: Add: name '[' unpacked ']')
+# (TODO: Add: name '[' type_expression_list (',' type_expression_list)* ']')
+# name '[' '(' ')' ']' (denoting specialization with an empty TypeVarTuple)
+typx = IntTuple[()]
+# <Literal> '[' expression (',' expression) ']'
+typx = Literal[1]
+# type_expression '|' type_expression
+typx = int | str
+# <Optional> '[' type_expression ']'
+typx = Optional[str]
+# <Union> '[' type_expression (',' type_expression)* ']'
+typx = Union[int, str]
+# <type> '[' <Any> ']'
+typx = type[Any]
+# <type> '[' name ']' (where name must refer to a valid in-scope class)
+typx = type[int]
+# (TODO: Add: <type> '[' name ']' (where name must refer to a valid in-scope TypeVar))
+# <Callable> '[' '...' ',' type_expression ']'
+typx = Callable[..., str]
+def bind_R(input: R) -> R:
+    typx: TypeForm
+    # <Callable> '[' name ',' type_expression ']' (where name must be a valid in-scope ParamSpec)
+    typx = Callable[P, R]
+    # <Callable> '[' <Concatenate> '[' (type_expression ',')+
+    #            (name | '...') ']' ',' type_expression ']'
+    #     (where name must be a valid in-scope ParamSpec)
+    typx = Callable[Concatenate[int, P], R]
+    return input
+# <Callable> '[' '[' maybe_unpacked (',' maybe_unpacked)* ']' ',' type_expression ']'
+typx = Callable[[int, str], None]
+# <tuple> '[' '(' ')' ']' (representing an empty tuple)
+typx = tuple[()]
+# <tuple> '[' type_expression ',' '...' ']' (representing an arbitrary-length tuple)
+typx = tuple[int, ...]
+# <tuple> '[' maybe_unpacked (',' maybe_unpacked)* ']'
+typx = tuple[int, str]
+# <Annotated> '[' type_expression ',' expression (',' expression)* ']'
+typx = Annotated[str, 'uppercase']
+# <TypeGuard> '[' type_expression ']' (valid only in some contexts)
+typx = TypeGuard[List[str]]
+# <TypeIs> '[' type_expression ']' (valid only in some contexts)
+typx = TypeIs[List[str]]
+# string_annotation (must evaluate to a valid type_expression)
+typx = 'int | str'
+# End rules
+[builtins fixtures/primitives.pyi]
+[typing fixtures/typing-full.pyi]
+
+
 -- Misc
 
 [case testTypeFormHasAllObjectAttributesAndMethods]