report all revealed types, not only those of the last iterations step

Author: tyralla

mypy/checker.py

@@ -637,15 +637,21 @@ def accept_loop(
                 if iter == 20:
                     raise RuntimeError("Too many iterations when checking a loop")
 
-            # Report those unreachable and redundant expression errors that have been
-            # identified in all iteration steps, as well as the revealed types identified
-            # in the last iteration step:
-            for notes_and_errors in itertools.chain(uselessness_errors, watcher.revealed_types):
-                context = Context(line=notes_and_errors[2], column=notes_and_errors[3])
-                context.end_line = notes_and_errors[4]
-                context.end_column = notes_and_errors[5]
-                reporter = self.msg.note if notes_and_errors[0] == codes.MISC else self.msg.fail
-                reporter(notes_and_errors[1], context, code=notes_and_errors[0])
+            # Report those unreachable and redundant expression errors identified in all
+            # iteration steps:
+            for error_info in uselessness_errors:
+                context = Context(line=error_info[2], column=error_info[3])
+                context.end_line = error_info[4]
+                context.end_column = error_info[5]
+                self.msg.fail(error_info[1], context, code=error_info[0])
+            #  Report all types revealed in at least one iteration step:
+            for note_info, types in watcher.revealed_types.items():
+                sorted_ = sorted(types, key=lambda typ: typ.lower())
+                revealed = sorted_[0] if len(types) == 1 else f"Union[{', '.join(sorted_)}]"
+                context = Context(line=note_info[1], column=note_info[2])
+                context.end_line = note_info[3]
+                context.end_column = note_info[4]
+                self.note(f'Revealed type is "{revealed}"', context)
 
             # If exit_condition is set, assume it must be False on exit from the loop:
             if exit_condition:

mypy/errors.py

@@ -222,12 +222,13 @@ def filtered_errors(self) -> list[ErrorInfo]:
 
 class LoopErrorWatcher(ErrorWatcher):
     """Error watcher that filters and separately collects unreachable errors, redundant
-    expression errors, and revealed type notes when analysing loops iteratively to help
-    avoid making too-hasty reports."""
+    expression errors, and revealed types when analysing loops iteratively to help avoid
+    making too-hasty reports."""
 
-    # Meaning of the entries: ErrorCode, message, line, column, end_line, end_column:
+    # Meaning of the tuple items: ErrorCode, message, line, column, end_line, end_column:
     useless_statements: set[tuple[ErrorCode, str, int, int, int, int]]
-    revealed_types: set[tuple[ErrorCode, str, int, int, int, int]]
+    # Meaning of the tuple items: function_or_member, line, column, end_line, end_column:
+    revealed_types: dict[tuple[str | None, int, int, int, int], set[str]]
 
     def __init__(
         self,
@@ -244,7 +245,7 @@ def __init__(
             filter_deprecated=filter_deprecated,
         )
         self.useless_statements = set()
-        self.revealed_types = set()
+        self.revealed_types = defaultdict(set)
 
     def on_error(self, file: str, info: ErrorInfo) -> bool:
         if info.code in (codes.UNREACHABLE, codes.REDUNDANT_EXPR):
@@ -253,9 +254,12 @@ def on_error(self, file: str, info: ErrorInfo) -> bool:
             )
             return True
         if info.code == codes.MISC and info.message.startswith("Revealed type is "):
-            self.revealed_types.add(
-                (info.code, info.message, info.line, info.column, info.end_line, info.end_column)
-            )
+            key = info.function_or_member, info.line, info.column, info.end_line, info.end_column
+            types = info.message.split('"')[1]
+            if types.startswith("Union["):
+                self.revealed_types[key].update(types[6:-1].split(", "))
+            else:
+                self.revealed_types[key].add(types)
             return True
         return super().on_error(file, info)
 

test-data/unit/check-inference.test

@@ -343,7 +343,7 @@ for var2 in [g, h, i, j, k, l]:
     reveal_type(var2)  # N: Revealed type is "Union[builtins.int, builtins.str]"
 
 for var3 in [m, n, o, p, q, r]:
-    reveal_type(var3)  # N: Revealed type is "Union[builtins.int, Any]"
+    reveal_type(var3)  # N: Revealed type is "Union[Any, builtins.int]"
 
 T = TypeVar("T", bound=Type[Foo])
 
@@ -1247,7 +1247,7 @@ class X(TypedDict):
 
 x: X
 for a in ("hourly", "daily"):
-    reveal_type(a)  # N: Revealed type is "Union[Literal['hourly']?, Literal['daily']?]"
+    reveal_type(a)  # N: Revealed type is "Union[Literal['daily']?, Literal['hourly']?]"
     reveal_type(x[a])  # N: Revealed type is "builtins.int"
     reveal_type(a.upper())  # N: Revealed type is "builtins.str"
     c = a

test-data/unit/check-redefine2.test

@@ -628,7 +628,7 @@ def f1() -> None:
 def f2() -> None:
     x = None
     while int():
-        reveal_type(x) # N: Revealed type is "Union[None, builtins.str]"
+        reveal_type(x) # N: Revealed type is "Union[builtins.str, None]"
         if int():
             x = ""
     reveal_type(x) # N: Revealed type is "Union[None, builtins.str]"
@@ -808,8 +808,7 @@ def f4() -> None:
                         x = None
                         break
         finally:
-            reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str, None]" \
-                # N: Revealed type is "Union[builtins.int, None]"
+            reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str, None]"
         reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
 [builtins fixtures/exception.pyi]
 
@@ -925,7 +924,7 @@ class X(TypedDict):
 
 x: X
 for a in ("hourly", "daily"):
-    reveal_type(a)  # N: Revealed type is "Union[Literal['hourly']?, Literal['daily']?]"
+    reveal_type(a)  # N: Revealed type is "Union[Literal['daily']?, Literal['hourly']?]"
     reveal_type(x[a])  # N: Revealed type is "builtins.int"
     reveal_type(a.upper())  # N: Revealed type is "builtins.str"
     c = a

test-data/unit/check-typevar-tuple.test

@@ -989,7 +989,7 @@ from typing_extensions import Unpack
 
 def pipeline(*xs: Unpack[Tuple[int, Unpack[Tuple[float, ...]], bool]]) -> None:
     for x in xs:
-        reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.float]"
+        reveal_type(x)  # N: Revealed type is "Union[builtins.float, builtins.int]"
 [builtins fixtures/tuple.pyi]
 
 [case testFixedUnpackItemInInstanceArguments]