Add some shortening for long unions

python · ilevkivskyi · Jun 22, 2024 · Jun 20, 2024 · Jun 22, 2024 · Jun 22, 2024
commit 59ab31c578516dd72782b347ce1044c0b0b0a1fd
diff --git a/mypy/messages.py b/mypy/messages.py
@@ -145,6 +145,9 @@
     "numbers.Integral",
 }
 
+MAX_TUPLE_ITEMS = 10
+MAX_UNION_ITEMS = 10
+
 
 class MessageBuilder:
     """Helper class for reporting type checker error messages with parameters.
@@ -2338,7 +2341,7 @@ def try_report_long_tuple_assignment_error(
         """
         if isinstance(subtype, TupleType):
             if (
-                len(subtype.items) > 10
+                len(subtype.items) > MAX_TUPLE_ITEMS
                 and isinstance(supertype, Instance)
                 and supertype.type.fullname == "builtins.tuple"
             ):
@@ -2347,7 +2350,7 @@ def try_report_long_tuple_assignment_error(
                 self.generate_incompatible_tuple_error(lhs_types, subtype.items, context, msg)
                 return True
             elif isinstance(supertype, TupleType) and (
-                len(subtype.items) > 10 or len(supertype.items) > 10
+                len(subtype.items) > MAX_TUPLE_ITEMS or len(supertype.items) > MAX_TUPLE_ITEMS
             ):
                 if len(subtype.items) != len(supertype.items):
                     if supertype_label is not None and subtype_label is not None:
@@ -2370,7 +2373,7 @@ def try_report_long_tuple_assignment_error(
     def format_long_tuple_type(self, typ: TupleType) -> str:
         """Format very long tuple type using an ellipsis notation"""
         item_cnt = len(typ.items)
-        if item_cnt > 10:
+        if item_cnt > MAX_TUPLE_ITEMS:
             return "{}[{}, {}, ... <{} more items>]".format(
                 "tuple" if self.options.use_lowercase_names() else "Tuple",
                 format_type_bare(typ.items[0], self.options),
@@ -2497,11 +2500,21 @@ def format(typ: Type) -> str:
     def format_list(types: Sequence[Type]) -> str:
         return ", ".join(format(typ) for typ in types)
 
-    def format_union(types: Sequence[Type]) -> str:
+    def format_union_items(types: Sequence[Type]) -> list[str]:
         formatted = [format(typ) for typ in types if format(typ) != "None"]
+        if len(formatted) > MAX_UNION_ITEMS and verbosity == 0:
+            more = len(formatted) - MAX_UNION_ITEMS // 2
+            formatted = formatted[:MAX_UNION_ITEMS // 2]
+        else:
+            more = 0
+        if more:
+            formatted.append(f"<{more} more items>")
         if any(format(typ) == "None" for typ in types):
             formatted.append("None")
-        return " | ".join(formatted)
+        return formatted
+
+    def format_union(types: Sequence[Type]) -> str:
+        return " | ".join(format_union_items(types))
 
     def format_literal_value(typ: LiteralType) -> str:
         if typ.is_enum_literal():
@@ -2627,7 +2640,7 @@ def format_literal_value(typ: LiteralType) -> str:
                 return (
                     f"{literal_str} | {format_union(union_items)}"
                     if options.use_or_syntax()
-                    else f"Union[{format_list(union_items)}, {literal_str}]"
+                    else f"Union[{', '.join(format_union_items(union_items))}, {literal_str}]"
                 )
             else:
                 return literal_str
@@ -2648,7 +2661,7 @@ def format_literal_value(typ: LiteralType) -> str:
                 s = (
                     format_union(typ.items)
                     if options.use_or_syntax()
-                    else f"Union[{format_list(typ.items)}]"
+                    else f"Union[{', '.join(format_union_items(typ.items))}]"
                 )
             return s
     elif isinstance(typ, NoneType):

diff --git a/test-data/unit/check-enum.test b/test-data/unit/check-enum.test
@@ -1010,7 +1010,7 @@ _empty: Final = Empty.token
 def func(x: Union[int, None, Empty] = _empty) -> int:
     boom = x + 42       # E: Unsupported left operand type for + ("None") \
                         # E: Unsupported left operand type for + ("Empty") \
-                        # N: Left operand is of type "Union[int, None, Empty]"
+                        # N: Left operand is of type "Union[int, Empty, None]"
     if x is _empty:
         reveal_type(x)  # N: Revealed type is "Literal[__main__.Empty.token]"
         return 0
@@ -1020,6 +1020,8 @@ def func(x: Union[int, None, Empty] = _empty) -> int:
     else:  # At this point typechecker knows that x can only have type int
         reveal_type(x)  # N: Revealed type is "builtins.int"
         return x + 2
+
+
 [builtins fixtures/primitives.pyi]
 
 [case testEnumReachabilityPEP484ExampleWithMultipleValues]
@@ -1056,7 +1058,7 @@ _empty = Empty.token
 def func(x: Union[int, None, Empty] = _empty) -> int:
     boom = x + 42       # E: Unsupported left operand type for + ("None") \
                         # E: Unsupported left operand type for + ("Empty") \
-                        # N: Left operand is of type "Union[int, None, Empty]"
+                        # N: Left operand is of type "Union[int, Empty, None]"
     if x is _empty:
         reveal_type(x)  # N: Revealed type is "Literal[__main__.Empty.token]"
         return 0
@@ -1066,6 +1068,8 @@ def func(x: Union[int, None, Empty] = _empty) -> int:
     else:  # At this point typechecker knows that x can only have type int
         reveal_type(x)  # N: Revealed type is "builtins.int"
         return x + 2
+
+
 [builtins fixtures/primitives.pyi]
 
 [case testEnumReachabilityPEP484ExampleSingletonWithMethod]
@@ -1084,7 +1088,7 @@ _empty = Empty.token
 def func(x: Union[int, None, Empty] = _empty) -> int:
     boom = x + 42       # E: Unsupported left operand type for + ("None") \
                         # E: Unsupported left operand type for + ("Empty") \
-                        # N: Left operand is of type "Union[int, None, Empty]"
+                        # N: Left operand is of type "Union[int, Empty, None]"
     if x is _empty:
         reveal_type(x)  # N: Revealed type is "Literal[__main__.Empty.token]"
         return 0
@@ -1094,6 +1098,8 @@ def func(x: Union[int, None, Empty] = _empty) -> int:
     else:  # At this point typechecker knows that x can only have type int
         reveal_type(x)  # N: Revealed type is "builtins.int"
         return x + 2
+
+
 [builtins fixtures/primitives.pyi]
 
 [case testAssignEnumAsAttribute]

diff --git a/test-data/unit/check-unions.test b/test-data/unit/check-unions.test
@@ -1289,3 +1289,58 @@ x: str = a_class_or_none.field
 a_or_none: Optional[A]
 y: int = a_or_none.field
 [builtins fixtures/list.pyi]
+
+[case testLargeUnionsShort]
+from typing import Union
+
+class C1: ...
+class C2: ...
+class C3: ...
+class C4: ...
+class C5: ...
+class C6: ...
+class C7: ...
+class C8: ...
+class C9: ...
+class C10: ...
+class C11: ...
+
+u: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11]
+x: int = u  # E: Incompatible types in assignment (expression has type "Union[C1, C2, C3, C4, C5, <6 more items>]", variable has type "int")
+
+[case testLargeUnionsLongIfNeeded]
+from typing import Union
+
+class C1: ...
+class C2: ...
+class C3: ...
+class C4: ...
+class C5: ...
+class C6: ...
+class C7: ...
+class C8: ...
+class C9: ...
+class C10: ...
+
+x: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, int]
+y: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, str]
+x = y  # E: Incompatible types in assignment (expression has type "Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, str]", variable has type "Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, int]")
+
+[case testLargeUnionsNoneShown]
+from typing import Union
+
+class C1: ...
+class C2: ...
+class C3: ...
+class C4: ...
+class C5: ...
+class C6: ...
+class C7: ...
+class C8: ...
+class C9: ...
+class C10: ...
+class C11: ...
+
+x: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11]
+y: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, None]
+x = y  # E: Incompatible types in assignment (expression has type "Union[C1, C2, C3, C4, C5, <6 more items>, None]", variable has type "Union[C1, C2, C3, C4, C5, <6 more items>]")