Eliminate use of Type Parameter Syntax, which only works on Python >= 3.12

Author: davidfstr

INPUTS/required/import_typing_notrequired.py

@@ -0,0 +1,5 @@
+import typing
+import typing_extensions
+
+assert typing.Required is typing_extensions.Required
+assert typing.NotRequired is typing_extensions.NotRequired

INPUTS/required/import_typing_notrequired2.py

@@ -0,0 +1,5 @@
+import typing
+import typing_extensions
+
+assert typing.Required is typing_extensions.Required
+assert typing.NotRequired is typing_extensions.NotRequired

INPUTS/required/required.py

@@ -0,0 +1,85 @@
+from typing import TypedDict, Tuple, Union
+from typing_extensions import NotRequired, Required
+
+
+# --- Class Based TypedDict ---
+class Movie(TypedDict, total=False):
+    title: Required[str]  # 5
+    year: int
+
+
+m = Movie(title='The Matrix', year=1999)
+# m = Movie()
+print(m)
+
+
+# --- Assignment Based TypedDict ---
+Movie2 = TypedDict('Movie2', {
+    'title': Required[str],
+    'year': int,
+}, total=False)
+
+
+m2 = Movie2(title='The Matrix Reloaded', year=2003)
+# m2 = Movie2()
+print(m2)
+
+
+# --- Required[] outside of TypedDict (error) ---
+x: int = 5
+# x: Required[int] = 5
+
+
+# --- Required[] inside other Required[] (error) ---
+'''
+Movie3 = TypedDict('Movie3', {
+    'title': Required[Union[
+        Required[str],
+        bytes
+    ]],
+    'year': int,
+}, total=False)
+'''
+
+
+# --- Required[] used within TypedDict but not at top level (error) ---
+'''
+Movie4 = TypedDict('Movie4', {
+    'title': Union[
+        Required[str],
+        bytes
+    ],
+    'year': int,
+}, total=False)
+Movie5 = TypedDict('Movie5', {
+    'title': Tuple[
+        Required[str],
+        bytes
+    ],
+    'year': int,
+}, total=False)
+'''
+
+
+# ==============================================================================
+# --- Class Based TypedDict ---
+class MovieN(TypedDict):
+    title: str
+    year: NotRequired[int]
+
+
+m = MovieN(title='The Matrix', year=1999)
+# m = MovieN()
+print(m)
+
+
+# --- Assignment Based TypedDict ---
+MovieN2 = TypedDict('MovieN2', {
+    'title': str,
+    'year': NotRequired[int],
+})
+
+
+m2 = MovieN2(title='The Matrix Reloaded', year=2003)
+# m2 = MovieN2()
+print(m2)

INPUTS/required/required_py3_11.py

@@ -0,0 +1,8 @@
+import typing
+
+class Movie(typing.TypedDict):
+    title: str
+    year: typing.NotRequired[int]
+
+m = Movie(title='The Matrix')
+print(m)

INPUTS/test_typeform.py

@@ -0,0 +1,38 @@
+from typing import Any, Callable, cast, Never, NoReturn, Optional, reveal_type, Type, TypeVar, TypedDict
+from typing_extensions import TypeForm, TypeGuard
+
+dict_with_typx_keys: dict[TypeForm, int] = {
+    int | str: 1,
+    str | None: 2,
+}
+dict_with_typx_keys[int | str] += 1
+
+#typx1: TypeForm[int | str] = 'int | str'  # OK
+#typx2: TypeForm[int] = 'str'  # E: Incompatible types in assignment (expression has type "TypeForm[str]", variable has type "TypeForm[int]")
+
+'''
+from typing import Any
+
+T = TypeVar('T')
+
+def as_typeform(typx: TypeForm[T]) -> TypeForm[T]:
+    return typx
+
+def as_type(typx: TypeForm[T]) -> Type[T] | None:
+    if isinstance(typx, type):
+        return typx
+    else:
+        return None
+
+def as_instance(typx: TypeForm[T]) -> T | None:
+    if isinstance(typx, type):
+        return typx()
+    else:
+        return None
+
+reveal_type(as_typeform(int | str))  # actual=TypeForm[Never], expect=TypeForm[int | str]
+reveal_type(as_type(int | str))
+reveal_type(as_type(int))
+reveal_type(as_instance(int | str))
+reveal_type(as_instance(int))
+'''

INPUTS/typeform_assign_to_alias.py

@@ -0,0 +1,5 @@
+from typing import TypeAlias, reveal_type
+
+alias: TypeAlias = int | None
+reveal_type(alias)
+

INPUTS/typeform_assignment.py

@@ -0,0 +1,9 @@
+typ: type
+typ = int
+
+# E: Incompatible types in assignment (expression has type "UnionType", variable has type "type")  [assignment]
+typ = str | None
+
+#from typing_extensions import TypeExpr as TypeForm
+#typx: TypeForm
+#typx = int | None

INPUTS/typeform_call.py

@@ -0,0 +1,5 @@
+def expect_type(typ: type) -> None:
+    pass
+
+# E: Argument 1 to "expect_type" has incompatible type "UnionType"; expected "type"  [arg-type]
+expect_type(str | None)

INPUTS/typeform_return.py

@@ -0,0 +1,5 @@
+def return_type() -> type:
+    # E: Incompatible return value type (got "UnionType", expected "type")  [return-value]
+    return str | None
+
+return_type()

test-data/unit/check-typeform.test

@@ -515,9 +515,10 @@ reveal_type(as_instance(int))  # N: Revealed type is "Union[builtins.int, None]"
 
 [case testLinkTypeFormToTypeIsWithTypeVariable]
 # flags: --python-version 3.14 --enable-incomplete-feature=TypeForm
-from typing import TypeForm
+from typing import TypeForm, TypeVar
 from typing_extensions import TypeIs
-def isassignable[T](value: object, typx: TypeForm[T]) -> TypeIs[T]:
+T = TypeVar('T')
+def isassignable(value: object, typx: TypeForm[T]) -> TypeIs[T]:
     raise BaseException()
 count: int | str = 1
 if isassignable(count, int):
@@ -529,9 +530,10 @@ else:
 
 [case testLinkTypeFormToTypeGuardWithTypeVariable]
 # flags: --python-version 3.14 --enable-incomplete-feature=TypeForm
-from typing import TypeForm
+from typing import TypeForm, TypeVar
 from typing_extensions import TypeGuard
-def isassignable[T](value: object, typx: TypeForm[T]) -> TypeGuard[T]:
+T = TypeVar('T')
+def isassignable(value: object, typx: TypeForm[T]) -> TypeGuard[T]:
     raise BaseException()
 count: int | str = 1
 if isassignable(count, int):