ilevkivskyi
diff --git a/‎src/typing.py
Lines changed: 64 additions & 81 deletions b/‎src/typing.py
Lines changed: 64 additions & 81 deletions
@@ -316,6 +316,12 @@ def _type_repr(obj):
 
 
 class _Any(Final, metaclass=TypingMeta, _root=True):
+    """Special type indicating an unconstrained type.
+
+    - Any object is an instance of Any.
+    - Any class is a subclass of Any.
+    - As a special case, Any and object are subclasses of each other.
+    """
 
     def __instancecheck__(self, obj):
         raise TypeError("Any cannot be used with isinstance().")
@@ -438,12 +444,64 @@ def __subclasscheck__(self, cls):
 AnyStr = TypeVar('AnyStr', bytes, str)
 
 
-class UnionMeta(TypingMeta):
-    """Metaclass for Union."""
+class _Union(Final, metaclass=TypingMeta, _root=True):
+        """Union type; Union[X, Y] means either X or Y.
+
+    To define a union, use e.g. Union[int, str].  Details:
+
+    - The arguments must be types and there must be at least one.
+
+    - None as an argument is a special case and is replaced by
+      type(None).
+
+    - Unions of unions are flattened, e.g.::
+
+        Union[Union[int, str], float] == Union[int, str, float]
+
+    - Unions of a single argument vanish, e.g.::
+
+        Union[int] == int  # The constructor actually returns int
+
+    - Redundant arguments are skipped, e.g.::
+
+        Union[int, str, int] == Union[int, str]
+
+    - When comparing unions, the argument order is ignored, e.g.::
+
+        Union[int, str] == Union[str, int]
+
+    - When two arguments have a subclass relationship, the least
+      derived argument is kept, e.g.::
 
-    def __new__(cls, name, bases, namespace, parameters=None, _root=False):
+        class Employee: pass
+        class Manager(Employee): pass
+        Union[int, Employee, Manager] == Union[int, Employee]
+        Union[Manager, int, Employee] == Union[int, Employee]
+        Union[Employee, Manager] == Employee
+
+    - Corollary: if Any is present it is the sole survivor, e.g.::
+
+        Union[int, Any] == Any
+
+    - Similar for object::
+
+        Union[int, object] == object
+
+    - To cut a tie: Union[object, Any] == Union[Any, object] == Any.
+
+    - You cannot subclass or instantiate a union.
+
+    - You cannot write Union[X][Y] (what would it mean?).
+
+    - You can use Optional[X] as a shorthand for Union[X, None].
+    """
+
+    def __new__(cls, parameters=None, _root=False):
+        self = object.__new__(cls)
         if parameters is None:
-            return super().__new__(cls, name, bases, namespace, _root=_root)
+            self.__union_params__ = None
+            self.__union_set_params__ = None
+            return self
         if not isinstance(parameters, tuple):
             raise TypeError("Expected parameters=<tuple>")
         # Flatten out Union[Union[...], ...] and type-check non-Union args.
@@ -474,11 +532,6 @@ def __new__(cls, name, bases, namespace, parameters=None, _root=False):
         for t1 in params:
             if t1 is Any:
                 return Any
-            if isinstance(t1, TypeVar):
-                continue
-            if isinstance(t1, _TypeAlias):
-                # _TypeAlias is not a real class.
-                continue
             if not isinstance(t1, type):
                 continue
             if any(isinstance(t2, type) and issubclass(t1, t2)
@@ -488,7 +541,6 @@ def __new__(cls, name, bases, namespace, parameters=None, _root=False):
         if len(all_params) == 1:
             return all_params.pop()
         # Create a new class with these params.
-        self = super().__new__(cls, name, bases, {}, _root=True)
         self.__union_params__ = tuple(t for t in params if t in all_params)
         self.__union_set_params__ = frozenset(self.__union_params__)
         return self
@@ -536,79 +588,10 @@ def __instancecheck__(self, obj):
         raise TypeError("Unions cannot be used with isinstance().")
 
     def __subclasscheck__(self, cls):
-        if cls is Any:
-            return True
-        if self.__union_params__ is None:
-            return isinstance(cls, UnionMeta)
-        elif isinstance(cls, UnionMeta):
-            if cls.__union_params__ is None:
-                return False
-            return all(issubclass(c, self) for c in (cls.__union_params__))
-        elif isinstance(cls, TypeVar):
-            if cls in self.__union_params__:
-                return True
-            if cls.__constraints__:
-                return issubclass(Union[cls.__constraints__], self)
-            return False
-        else:
-            return any(issubclass(cls, t) for t in self.__union_params__)
-
-
-class Union(Final, metaclass=UnionMeta, _root=True):
-    """Union type; Union[X, Y] means either X or Y.
-
-    To define a union, use e.g. Union[int, str].  Details:
-
-    - The arguments must be types and there must be at least one.
-
-    - None as an argument is a special case and is replaced by
-      type(None).
-
-    - Unions of unions are flattened, e.g.::
-
-        Union[Union[int, str], float] == Union[int, str, float]
-
-    - Unions of a single argument vanish, e.g.::
-
-        Union[int] == int  # The constructor actually returns int
-
-    - Redundant arguments are skipped, e.g.::
-
-        Union[int, str, int] == Union[int, str]
-
-    - When comparing unions, the argument order is ignored, e.g.::
+        raise TypeError("Unions cannot be used with issubclass().")
 
-        Union[int, str] == Union[str, int]
-
-    - When two arguments have a subclass relationship, the least
-      derived argument is kept, e.g.::
-
-        class Employee: pass
-        class Manager(Employee): pass
-        Union[int, Employee, Manager] == Union[int, Employee]
-        Union[Manager, int, Employee] == Union[int, Employee]
-        Union[Employee, Manager] == Employee
-
-    - Corollary: if Any is present it is the sole survivor, e.g.::
-
-        Union[int, Any] == Any
-
-    - Similar for object::
-
-        Union[int, object] == object
-
-    - To cut a tie: Union[object, Any] == Union[Any, object] == Any.
-
-    - You cannot subclass or instantiate a union.
-
-    - You cannot write Union[X][Y] (what would it mean?).
-
-    - You can use Optional[X] as a shorthand for Union[X, None].
-    """
 
-    # Unsubscripted Union type has params set to None.
-    __union_params__ = None
-    __union_set_params__ = None
+Union(Final, metaclass=UnionMeta, _root=True):
 
 
 class OptionalMeta(TypingMeta):