Flatten TypeAliasType when it is aliased as a Union (#8146)

Resolves #8125 

The main problem is not about flattening unions inside variants since the following code generates no error
```python
from typing import Union

T1 = Union[int, float]
T2 = Union[Union[Union[int, float], float], Union[float, complex], complex]

def foo(a: T2, b: T2) -> T2:
    return a + b
```

The problem, however, is because when using `TypeAliasType` to alias a Union, the `TypeAliasType` will not get flattened, so this PR fixes this.

Author: TH3CHARLie

mypy/checkexpr.py

@@ -19,7 +19,7 @@
     PartialType, DeletedType, UninhabitedType, TypeType, TypeOfAny, LiteralType, LiteralValue,
     is_named_instance, FunctionLike,
     StarType, is_optional, remove_optional, is_generic_instance, get_proper_type, ProperType,
-    get_proper_types
+    get_proper_types, flatten_nested_unions
 )
 from mypy.nodes import (
     NameExpr, RefExpr, Var, FuncDef, OverloadedFuncDef, TypeInfo, CallExpr,
@@ -2589,7 +2589,9 @@ def check_op(self, method: str, base_type: Type,
             left_variants = [base_type]
             base_type = get_proper_type(base_type)
             if isinstance(base_type, UnionType):
-                left_variants = [item for item in base_type.relevant_items()]
+                left_variants = [item for item in
+                                 flatten_nested_unions(base_type.relevant_items(),
+                                                       handle_type_alias_type=True)]
             right_type = self.accept(arg)
 
             # Step 1: We first try leaving the right arguments alone and destructure
@@ -2632,8 +2634,8 @@ def check_op(self, method: str, base_type: Type,
             right_type = get_proper_type(right_type)
             if isinstance(right_type, UnionType):
                 right_variants = [(item, TempNode(item, context=context))
-                                  for item in right_type.relevant_items()]
-
+                                  for item in flatten_nested_unions(right_type.relevant_items(),
+                                                                    handle_type_alias_type=True)]
             msg = self.msg.clean_copy()
             msg.disable_count = 0
             all_results = []

mypy/types.py

@@ -2236,15 +2236,19 @@ def has_type_vars(typ: Type) -> bool:
     return typ.accept(HasTypeVars())
 
 
-def flatten_nested_unions(types: Iterable[Type]) -> List[Type]:
+def flatten_nested_unions(types: Iterable[Type],
+                          handle_type_alias_type: bool = False) -> List[Type]:
     """Flatten nested unions in a type list."""
     # This and similar functions on unions can cause infinite recursion
     # if passed a "pathological" alias like A = Union[int, A] or similar.
     # TODO: ban such aliases in semantic analyzer.
     flat_items = []  # type: List[Type]
+    if handle_type_alias_type:
+        types = get_proper_types(types)
     for tp in types:
         if isinstance(tp, ProperType) and isinstance(tp, UnionType):
-            flat_items.extend(flatten_nested_unions(tp.items))
+            flat_items.extend(flatten_nested_unions(tp.items,
+                              handle_type_alias_type=handle_type_alias_type))
         else:
             flat_items.append(tp)
     return flat_items

test-data/unit/check-unions.test

@@ -1013,3 +1013,18 @@ y: Union[int, Dict[int, int]] = 1 if bool() else {}
 u: Union[int, List[int]] = [] if bool() else 1
 v: Union[int, Dict[int, int]] = {} if bool() else 1
 [builtins fixtures/isinstancelist.pyi]
+
+[case testFlattenTypeAliasWhenAliasedAsUnion]
+from typing import Union
+
+T1 = int
+T2 = Union[T1, float]
+T3 = Union[T2, complex]
+T4 = Union[T3, int]
+
+def foo(a: T2, b: T2) -> T2:
+    return a + b
+
+def bar(a: T4, b: T4) -> T4:  # test multi-level alias
+    return a + b
+[builtins fixtures/ops.pyi]

test-data/unit/fixtures/ops.pyi

@@ -64,6 +64,10 @@ class float:
     def __truediv__(self, x: 'float') -> 'float': pass
     def __rtruediv__(self, x: 'float') -> 'float': pass
 
+class complex:
+    def __add__(self, x: complex) -> complex: pass
+    def __radd__(self, x: complex) -> complex: pass
+
 class BaseException: pass
 
 def __print(a1=None, a2=None, a3=None, a4=None): pass