tests/extmod: Add tests for typing PEPs.

PEP 484	Type Hints Python 3.5
PEP 526	Syntax for Variable Annotations	Python 3.6
PEP 544	Protocols: Structural subtyping (static duck typing) Python 3.8
PEP 560	Core support for typing module and generic types Python 3.7
PEP 586	Literal Types Python 3.8
PEP 589	TypedDict: Type Hints for Dictionaries with a Fixed Set of Keys Python 3.8
PEP 591	Adding a final qualifier to typing Python 3.8

Signed-off-by: Jos Verlinde <[email protected]>

Author: Josverl

tests/extmod/typing_pep_0484.py

@@ -0,0 +1,187 @@
+try:
+    from typing import TYPE_CHECKING
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+print("# Python 3.5")
+print("### PEP 484")
+
+# https://peps.python.org/topic/typing/
+# https://peps.python.org/pep-0484/
+
+# Currently excludes tests using `Generic[T]` due to MicroPython runtime limitations
+
+
+print("Running PEP 484 example-based test")
+
+
+print("Type Definition Syntax")
+
+
+def greeting(name: str) -> str:
+    return "Hello " + name
+
+
+print("greeting:", greeting("world"))
+
+from typing import List
+
+l: List[int]
+
+
+print("Type aliases")
+
+Url = str
+
+
+def retry(url: Url, retry_count: int) -> None:
+    print("retry", url, retry_count)
+
+
+retry("http://example", 3)
+
+
+print("Callable example")
+from typing import Callable, TypeVar, Union
+
+
+def feeder(get_next_item: Callable[[], str]) -> None:
+    try:
+        v = get_next_item()
+        print("feeder got", v)
+    except Exception as e:
+        print("feeder runtime exception:", e)
+
+
+def get_const():
+    return "x"
+
+
+feeder(get_const)
+
+
+print("TypeVar constrained example")
+AnyStr = TypeVar("AnyStr", str, bytes)
+
+
+def concat(x: AnyStr, y: AnyStr) -> AnyStr:
+    return x + y
+
+
+print("concat:", concat("a", "b"))
+
+# Generic user-defined class
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+# FIXME: Crash - inheriting from typing.Generic[T] unsupported at runtime
+# try:
+#
+#     class LoggedVar(Generic[T]):
+#         pass
+#
+#         def __init__(self, value: T, name: str) -> None:
+#             self.name = name
+#             self.value = value
+#
+#         def set(self, new: T) -> None:
+#             self.value = new
+#
+#         def get(self) -> T:
+#             return self.value
+#
+# except Exception as e:
+#     print("-[ ] FIXME: Difference - Generic[T] base class unsupported:", e)
+
+
+# Union/Optional examples
+def handle_employee(e: Union[str, None]) -> None:
+    print("handle_employee called with", e)
+
+
+handle_employee("John")
+handle_employee(None)
+
+
+# Any example
+def use_map(m: dict) -> None:
+    print("use_map keys:", list(m.keys()))
+
+
+use_map({"a": 1})
+
+# NewType example: at runtime NewType returns identity function
+try:
+    from typing import NewType
+
+    UserId = NewType("UserId", int)
+    v = UserId(5)
+    print("NewType UserId runtime:", v, type(v))
+except Exception as e:
+    print("-[ ] FIXME: Difference or Crash - NewType runtime issue:", e)
+
+print("TYPE_CHECKING guard")
+
+from typing import TYPE_CHECKING
+
+# TYPE_CHECKING guard
+if TYPE_CHECKING:
+    # This block is for type checkers only
+    pass
+    print("typing.TYPE_CHECKING is True at runtime. ERROR")
+else:
+    print("typing.TYPE_CHECKING is False at runtime as expected")
+
+
+print("Forward reference example")
+
+
+class Tree:
+    def __init__(self, left: "Tree" = None, right: "Tree" = None):  # type: ignore
+        self.left = left
+        self.right = right
+
+
+tr = Tree()
+print("Tree forward refs OK")
+
+# NoReturn example
+from typing import NoReturn
+
+
+def stop() -> NoReturn:
+    raise RuntimeError("stop")
+
+
+try:
+    stop()
+except RuntimeError:
+    print("stop() raised RuntimeError as expected (NoReturn at runtime)")
+
+# Overload example (runtime @overload should not be called directly)
+from typing import overload
+
+
+@overload
+def func(x: int) -> int:
+    ...
+
+
+@overload
+def func(x: str) -> str:
+    ...
+
+
+def func(x):
+    return x
+
+
+print("overload func for int:", func(1))
+
+# Cast example: at runtime cast returns the value
+from typing import cast
+
+print("cast runtime identity:", cast(str, 123))
+
+print("-----")

tests/extmod/typing_pep_0526.py

@@ -0,0 +1,167 @@
+try:
+    from typing import TYPE_CHECKING
+except Exception:
+    print("SKIP")
+    raise SystemExit
+
+print("# Python 3.6")
+print("### PEP 526 - Syntax for variable annotations")
+
+# https://peps.python.org/pep-0526/
+# Currently excludes tests using `Generic[T]` due to MicroPython runtime limitations
+
+
+print("Specification")
+
+my_var: int
+my_var = 5  # Passes type check.
+other_var: int = "a"  # Flagged as error by type checker, # type: ignore
+# but OK at runtime.
+
+
+print("Global and local variable annotations")
+from typing import List, Tuple, Optional
+
+some_number: int  # variable without initial value
+some_list: List[int] = []  # variable with initial value
+
+
+sane_world: bool
+if 2 + 2 == 4:
+    sane_world = True
+else:
+    sane_world = False
+
+# Tuple packing with variable annotation syntax
+t: Tuple[int, ...] = (1, 2, 3)
+# or
+t: Tuple[int, ...] = 1, 2, 3  # This only works in Python 3.8+
+
+# Tuple unpacking with variable annotation syntax
+header: str
+kind: int
+body: Optional[List[str]]
+
+a: int  # type: ignore
+try:
+    print(a)  # raises NameError # type: ignore
+
+except NameError:
+    print("Expected NameError")
+
+
+def f_1():
+    a: int
+    try:
+        print(a)  # raises UnboundLocalError # type: ignore
+    except UnboundLocalError:
+        print("Expected UnboundLocalError")
+
+
+a: int  # type: ignore
+a: str  # Static type checker may or may not warn about this.
+
+
+print("Class and instance variable annotations")
+from typing import ClassVar, Dict
+
+
+class BasicStarship:
+    captain: str = "Picard"  # instance variable with default
+    damage: int  # instance variable without default
+    stats: ClassVar[Dict[str, int]] = {}  # class variable
+
+
+class Starship_1:
+    captain = "Picard"
+    stats = {}
+
+    def __init__(self, damage, captain=None):
+        self.damage = damage
+        if captain:
+            self.captain = captain  # Else keep the default
+
+    def hit(self):
+        Starship.stats["hits"] = Starship.stats.get("hits", 0) + 1
+
+
+class Starship:
+    captain: str = "Picard"
+    damage: int
+    stats: ClassVar[Dict[str, int]] = {}
+
+    def __init__(self, damage: int, captain: str = None):  # type: ignore
+        self.damage = damage
+        if captain:
+            self.captain = captain  # Else keep the default
+
+    def hit(self):
+        Starship.stats["hits"] = Starship.stats.get("hits", 0) + 1
+
+
+enterprise_d = Starship(3000)
+enterprise_d.stats = {}  # Flagged as error by a type checker # type: ignore
+Starship.stats = {}  # This is OK
+
+
+# FIXME: - cpy_diff - User Defined Generic Classes unsupported
+# from typing import Generic, TypeVar
+# T = TypeVar("T")
+# class Box(Generic[T]):
+#     def __init__(self, content):
+#         self.content: T = content
+
+
+print("Annotating expressions")
+
+
+class Cls:
+    pass
+
+
+c = Cls()
+c.x: int = 0  # Annotates c.x with int. # type: ignore
+c.y: int  # Annotates c.y with int.# type: ignore
+
+d = {}
+d["a"]: int = 0  # Annotates d['a'] with int.# type: ignore
+d["b"]: int  # Annotates d['b'] with int.# type: ignore
+
+(x): int  # Annotates x with int, (x) treated as expression by compiler.# type: ignore
+(y): int = 0  # Same situation here.
+
+
+# print("Where annotations aren’t allowed")
+# The Examples crash both CPython and MicroPython at runtime.
+
+print("Runtime Effects of Type Annotations")
+
+
+def f():
+    x: NonexistentName  # No RUNTIME error. # type: ignore
+
+
+# FIXME: cpy_diff - MicroPython does not raise NameError at runtime
+# try:
+#     x: NonexistentName  # Error!
+#     print("-[ ] FIXME: Expected NameError")
+# except NameError:
+#     print("Expected NameError:")
+
+# try:
+
+#     class X:
+#         var: NonexistentName  # Error!
+# except NameError:
+#     print("Expected NameError:")
+
+
+# FIXME: cpy_diff - MicroPython does not provide the ``__annotations__`` dict at runtime
+# print(__annotations__)
+# __annotations__["s"] = str
+
+
+alice: "well done" = "A+"  # type: ignore
+bob: "what a shame" = "F-"  # type: ignore
+
+print("-----")