render literals better

Author: KotlinIsland

.mypy/baseline.json

@@ -3726,7 +3726,7 @@
       {
         "code": "no-any-expr",
         "column": 20,
-        "message": "Expression type contains \"Any\" (has type \"Literal[True] | str | Any | None\")",
+        "message": "Expression type contains \"Any\" (has type \"True | str | Any | None\")",
         "offset": 1,
         "target": "mypy.checkstrformat.StringFormatterChecker.check_specs_in_format_call"
       },
@@ -5156,7 +5156,7 @@
       {
         "code": "no-any-expr",
         "column": 24,
-        "message": "Expression type contains \"Any\" (has type \"Literal[False] | Any\")",
+        "message": "Expression type contains \"Any\" (has type \"False | Any\")",
         "offset": 0,
         "target": "mypy.config_parser.destructure_overrides"
       },
@@ -11546,7 +11546,7 @@
         "code": "no-any-expr",
         "column": 30,
         "message": "Expression type contains \"Any\" (has type \"type[CallableType]\")",
-        "offset": 329,
+        "offset": 330,
         "target": "mypy.join.TypeJoinVisitor.visit_callable_type"
       },
       {
@@ -13460,7 +13460,7 @@
         "code": "no-any-expr",
         "column": 30,
         "message": "Expression type contains \"Any\" (has type \"type[CallableType]\")",
-        "offset": 272,
+        "offset": 277,
         "target": "mypy.messages.format_type_inner"
       },
       {
@@ -16472,7 +16472,7 @@
       {
         "code": "no-any-expr",
         "column": 20,
-        "message": "Expression type contains \"Any\" (has type \"Literal[True] | Any\")",
+        "message": "Expression type contains \"Any\" (has type \"True | Any\")",
         "offset": 2,
         "target": "mypy.semanal.SemanticAnalyzer._get_node_for_class_scoped_import"
       },
@@ -23263,7 +23263,7 @@
       {
         "code": "no-any-expr",
         "column": 11,
-        "message": "Expression type contains \"Any\" (has type \"Literal[False] | Untyped\")",
+        "message": "Expression type contains \"Any\" (has type \"False | Untyped\")",
         "offset": 107,
         "target": "mypy.test.testcheck.TypeCheckSuite.run_case_once"
       },
@@ -26694,7 +26694,7 @@
         "code": "no-any-expr",
         "column": 23,
         "message": "Expression type contains \"Any\" (has type \"type[CallableType]\")",
-        "offset": 95,
+        "offset": 97,
         "target": "mypy.types.strip_type"
       },
       {
@@ -32464,7 +32464,7 @@
       {
         "code": "no-any-expr",
         "column": 7,
-        "message": "Expression type contains \"Any\" (has type \"Literal[False] | Untyped\")",
+        "message": "Expression type contains \"Any\" (has type \"False | Untyped\")",
         "offset": 59,
         "target": "mypyc.test.testutil.assert_test_output"
       },

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## [Unreleased]
 ### Enhancements
 - Unionize at type joins instead of common ancestor
+- Render Literal types better in output messages
 
 ## [1.4.0]
 ### Added

mypy/messages.py

@@ -2252,8 +2252,13 @@ def format_literal_value(typ: LiteralType) -> str:
         s = f"TypedDict({{{', '.join(items)}}})"
         return s
     elif isinstance(typ, LiteralType):
+        if mypy.options._based:
+            return format_literal_value(typ)
         return f"Literal[{format_literal_value(typ)}]"
     elif isinstance(typ, UnionType):
+        if mypy.options._based:
+            return " | ".join(format(item) for item in typ.items)
+
         literal_items, union_items = separate_union_literals(typ)
 
         # Coalesce multiple Literal[] members. This also changes output order.
@@ -2264,14 +2269,9 @@ def format_literal_value(typ: LiteralType) -> str:
             )
 
             if len(union_items) == 1 and isinstance(get_proper_type(union_items[0]), NoneType):
-                if mypy.options._based:
-                    return f"{literal_str} | None"
-                else:
-                    return f"Optional[{literal_str}]"
+                return f"Optional[{literal_str}]"
             elif union_items:
-                if not mypy.options._based:
-                    return f"Union[{format_list(union_items)}, {literal_str}]"
-                return f"{format_union(union_items)} | {literal_str}"
+                return f"Union[{format_list(union_items)}, {literal_str}]"
             else:
                 return literal_str
         else:
@@ -2282,15 +2282,9 @@ def format_literal_value(typ: LiteralType) -> str:
             )
             if print_as_optional:
                 rest = [t for t in typ.items if not isinstance(get_proper_type(t), NoneType)]
-                if mypy.options._based:
-                    return f"{format(rest[0])} | None"
-                else:
-                    return f"Optional[{format(rest[0])}]"
+                return f"Optional[{format(rest[0])}]"
             else:
-                if mypy.options._based:
-                    s = format_union(typ.items)
-                else:
-                    s = f"Union[{format_list(typ.items)}]"
+                s = f"Union[{format_list(typ.items)}]"
 
             return s
     elif isinstance(typ, NoneType):

mypy/types.py

@@ -3104,6 +3104,8 @@ def visit_raw_expression_type(self, t: RawExpressionType) -> str:
         return repr(t.literal_value)
 
     def visit_literal_type(self, t: LiteralType) -> str:
+        if mypy.options._based:
+            return t.value_repr()
         return f"Literal[{t.value_repr()}]"
 
     def visit_star_type(self, t: StarType) -> str:

test-data/unit/check-based-type-render.test

@@ -23,3 +23,16 @@ a: list
 reveal_type(a)  # N: Revealed type is "list[Untyped]"
 b: List[Any]
 reveal_type(b)  # N: Revealed type is "list[Any]"
+
+
+[case testRenderBareLiterals]
+# flags: --python-version 3.10
+from typing import Literal
+
+a: Literal['1'] = 2  # E: Incompatible types in assignment (expression has type "2", variable has type "'1'")  [assignment]
+reveal_type(a)  # N: Revealed type is "'1'"
+b: Literal[1, 2, 3] = 4  # E: Incompatible types in assignment (expression has type "4", variable has type "1 | 2 | 3")  [assignment]
+reveal_type(b)  # N: Revealed type is "1 | 2 | 3"
+c: Literal[1, 2, 3] | str = 4  # E: Incompatible types in assignment (expression has type "4", variable has type "1 | 2 | 3 | str")  [assignment]
+reveal_type(c)  # N: Revealed type is "1 | 2 | 3 | str"
+[typing fixtures/typing-medium.pyi]

test-data/unit/fixtures/tuple.pyi

@@ -43,6 +43,6 @@ class list(Sequence[T], Generic[T]):
 
 def isinstance(x: object, t: type) -> bool: pass
 
-def sum(iterable: Iterable[T], start: T = ...) -> T: pass
+def sum(iterable: Iterable[T], start: T = None) -> T: pass  # type: ignore[assignment, unused-ignore]
 
 class BaseException: pass

test-data/unit/fixtures/typing-medium.pyi

@@ -52,7 +52,7 @@ class Generator(Iterator[T], Generic[T, U, V]):
     def __iter__(self) -> 'Generator[T, U, V]': pass
 
 class Sequence(Iterable[T_co]):
-    def __getitem__(self, n: Any) -> T_co: pass
+    def __getitem__(self, n: Any) -> T_co: pass  # type: ignore[no-any-explicit, unused-ignore]
 
 class Mapping(Iterable[T], Generic[T, T_co]):
     def __getitem__(self, key: T) -> T_co: pass
@@ -66,6 +66,6 @@ class SupportsFloat(Protocol):
 class ContextManager(Generic[T]):
     def __enter__(self) -> T: pass
     # Use Any because not all the precise types are in the fixtures.
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: pass
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: pass  # type: ignore[no-any-explicit, unused-ignore]
 
 TYPE_CHECKING = 1