show 'narrowed from' in reveal_type

Author: Morgan Bartholomew

CHANGELOG.md

@@ -1,6 +1,8 @@
 # Basedmypy Changelog
 
 ## [Unreleased]
+### Enhancements
+- Show 'narrowed from' in `reveal_type` (#550)
 ### Fixes
 - Render star args in error messages properly (#551)
 

docs/source/based_features.rst

@@ -253,3 +253,15 @@ Basedmypy shows::
 
     Revealed type is "(T@f, str | 1 | 2)"
     Revealed type is "def [T: int] (a: T, b: str | 1 | 2) -> Never"
+
+
+Reveal Type Narrowed
+--------------------
+
+The defined type of a variable will be shown in the message for `reveal_type`:
+
+.. code-block:: python
+
+    a: object
+    a = 1
+    reveal_type(a)  # Revealed type is "int" (narrowed from "object")

mypy/checkexpr.py

@@ -4491,8 +4491,26 @@ def visit_reveal_expr(self, expr: RevealExpr) -> Type:
             revealed_type = self.accept(
                 expr.expr, type_context=self.type_context[-1], allow_none_return=True
             )
+
+            defined = None
+            if isinstance(expr.expr, NameExpr):
+                if isinstance(expr.expr.node, Var):
+                    defined = expr.expr.node.type
+            # TODO: attributes, methods, properties
+            # elif isinstance(expr.expr, MemberExpr):
+            #     if isinstance(expr.expr.expr, NameExpr):
+            #         if isinstance(expr.expr.expr.node, Var):
+            #             ert = expr.expr.expr.node.type
+            #             if isinstance(ert, Instance):
+            #                 a = ert.type.names.get(expr.expr.name)
+            #                 if a:
+            #                     defined = a.type
+
+            if not mypy.options._based:
+                defined = None
+
             if not self.chk.current_node_deferred:
-                self.msg.reveal_type(revealed_type, expr.expr)
+                self.msg.reveal_type(revealed_type, expr.expr, defined=defined)
                 if not self.chk.in_checked_function():
                     self.msg.note(
                         "'reveal_type' always outputs 'Any' in unchecked functions", expr.expr

mypy/messages.py

@@ -1727,9 +1727,21 @@ def invalid_signature_for_special_method(
             context,
         )
 
-    def reveal_type(self, typ: Type, context: Context) -> None:
+    def reveal_type(self, typ: Type, context: Context, defined: Type | None = None) -> None:
         visitor = TypeStrVisitor(options=self.options)
-        self.note(f'Revealed type is "{typ.accept(visitor)}"', context, code=codes.REVEAL)
+        type_string = typ.accept(visitor)
+        defined_string = ""
+        if defined:
+            defined_string = defined.accept(visitor)
+            if defined_string.replace("partially defined: ", "") == type_string.replace(
+                "Any (unannotated)", "?"
+            ):
+                type_string = defined_string
+                defined_string = ""
+        message = f'Revealed type is "{type_string}"'
+        if defined_string:
+            message += f' (narrowed from "{defined_string}")'
+        self.note(message, context, code=codes.REVEAL)
 
     def reveal_locals(self, type_map: dict[str, Type | None], context: Context) -> None:
         # To ensure that the output is predictable on Python < 3.6,

mypy/test/helpers.py

@@ -357,7 +357,6 @@ def parse_options(
             raise RuntimeError("Specifying targets via the flags pragma is not supported.")
         if not based and "--show-error-codes" not in flag_list:
             options.hide_error_codes = True
-        print(options.pretty)
     else:
         flag_list = []
         options = Options()

mypy/types.py

@@ -3636,9 +3636,11 @@ def visit_intersection_type(self, t: IntersectionType) -> str:
 
     def visit_partial_type(self, t: PartialType) -> str:
         if t.type is None:
-            return "<partial None>"
+            return "partially defined: ? | None"
         else:
-            return "<partial {}[{}]>".format(t.type.name, ", ".join(["?"] * len(t.type.type_vars)))
+            return "partially defined: {}[{}]".format(
+                t.type.name, ", ".join(["?"] * len(t.type.type_vars))
+            )
 
     def visit_ellipsis_type(self, t: EllipsisType) -> str:
         return "..."

test-data/unit/check-based-intersection.test

@@ -60,7 +60,7 @@ class B: pass
 
 i: A
 assert isinstance(i, B)
-reveal_type(i)  # N: Revealed type is "__main__.A & __main__.B"
+reveal_type(i)  # N: Revealed type is "__main__.A & __main__.B" (narrowed from "__main__.A")
 [builtins fixtures/tuple.pyi]
 
 
@@ -146,7 +146,7 @@ a = ""
 
 b: Any
 assert isinstance(b, str)
-reveal_type(b)  # N: Revealed type is "str"
+reveal_type(b)  # N: Revealed type is "str" (narrowed from "Any")
 [builtins fixtures/tuple.pyi]
 
 

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

@@ -92,3 +92,30 @@ def f2(*args: int, **kwargs: str): ...
 a = f2
 a = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "(*args: int, **kwargs: str) -> None")  [assignment]
 [builtins fixtures/tuple.pyi]
+
+
+[case testNarrowedFrom]
+a: object
+a = 1
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
+
+
+[case testNarrowedFromClass]
+# XFAIL
+class A:
+    a: object
+class B(A):
+    a: int
+a: A
+a = B()
+reveal_type(a.a)  # N: Revealed type is "int"
+# Actually expected N: Revealed type is "int" (narrowed from "object")
+
+
+[case testNarrowedFromPartial]
+a = []  # E: Need type annotation for "a" (hint: "a: list[<type>] = ...")  [var-annotated]
+reveal_type(a)  # E: Expression type contains "Any" (has type "list[Any (unannotated)]")  [no-any-expr] \
+                # E: Expression type contains "Any" (has type "list[Any (unannotated)]")  [no-any-expr] \
+                # N: Revealed type is "partially defined: list[?]"
+b = None  # E: Need type annotation for "b" (hint: "b: Optional[<type>] = ...")  [var-annotated]
+reveal_type(b)  # N: Revealed type is "None" (narrowed from "partially defined: ? | None")

test-data/unit/check-based-typeguard.test

@@ -7,11 +7,11 @@ def r(t: T) -> T: ...
 a: object
 f2 = r(f)
 assert f2(a)
-reveal_type(a)  # N: Revealed type is "int"
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
 
 b: object
 assert (lambda x: (lambda y: r(f)(y))(x))(b)
-reveal_type(b)  # N: Revealed type is "int"
+reveal_type(b)  # N: Revealed type is "int" (narrowed from "object")
 [builtins fixtures/tuple.pyi]
 
 
@@ -21,7 +21,7 @@ def f(it: object) -> TypeGuard[int]: ...
 
 a: object
 assert (lambda: f(a))()
-reveal_type(a)  # N: Revealed type is "int"
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
 [builtins fixtures/tuple.pyi]
 
 
@@ -42,13 +42,13 @@ def guard(x: object) -> "x is int": ...
 
 o: object
 if (lambda y: guard(y))(o):
-    reveal_type(o)  # N: Revealed type is "int"
+    reveal_type(o)  # N: Revealed type is "int" (narrowed from "object")
 
 if (lambda _, y: guard(y))(1, o):
-    reveal_type(o)  # N: Revealed type is "int"
+    reveal_type(o)  # N: Revealed type is "int" (narrowed from "object")
 
 if (lambda _, y: guard(x=y))(1, o):
-    reveal_type(o)  # N: Revealed type is "int"
+    reveal_type(o)  # N: Revealed type is "int" (narrowed from "object")
 
 if (lambda _, y: guard(y))(o, 1):
     reveal_type(o)  # N: Revealed type is "object"
@@ -58,7 +58,7 @@ class A:
 class B(A): ...
 a: A
 assert (lambda x: x.guard())(a)
-reveal_type(a)  # N: Revealed type is "__main__.B"
+reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 [builtins fixtures/tuple.pyi]
 
 
@@ -117,7 +117,7 @@ class A:
 
 a: object
 assert A.guard(A(), a)
-reveal_type(a)  # N: Revealed type is "int"
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
 [builtins fixtures/tuple.pyi]
 
 
@@ -129,7 +129,7 @@ class B(A): ...
 
 a: A
 assert a.guard()
-reveal_type(a)  # N: Revealed type is "__main__.B"
+reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 
 
 [case testGuardCls]
@@ -142,7 +142,7 @@ class B(A): ...
 
 a: Type[A]
 assert a.guard()
-reveal_type(a)  # N: Revealed type is "type[__main__.B]"
+reveal_type(a)  # N: Revealed type is "type[__main__.B]" (narrowed from "type[__main__.A]")
 [builtins fixtures/classmethod.pyi]
 
 
@@ -151,7 +151,7 @@ def guard(x: object, /) -> "x is int": ...
 
 a: object
 assert guard(a)
-reveal_type(a)  # N: Revealed type is "int"
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
 reveal_type(guard)  # N: Revealed type is "def (object) -> argument 1 is int"
 [builtins fixtures/tuple.pyi]
 
@@ -161,7 +161,7 @@ from __future__ import annotations
 def guard(x: object) -> x is int: ...
 a: object
 assert guard(a)
-reveal_type(a)  # N: Revealed type is "int"
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
 [builtins fixtures/tuple.pyi]
 
 
@@ -180,7 +180,7 @@ def make_guard() -> Callable[[object], TypeGuard[int]]: ...
 a: object
 assert make_guard()()  # E: Too few arguments  [call-arg]
 assert make_guard()(a)
-reveal_type(a)  # N: Revealed type is "int"
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
 [builtins fixtures/tuple.pyi]
 
 
@@ -190,7 +190,7 @@ class A:
 class B(A): ...
 
 assert (a := A()).g()
-reveal_type(a)  # N: Revealed type is "__main__.B"
+reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 [builtins fixtures/tuple.pyi]
 
 
@@ -225,7 +225,7 @@ class B(A): ...
 
 a: A
 assert a()
-reveal_type(a)  # N: Revealed type is "__main__.B"
+reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 [builtins fixtures/tuple.pyi]
 
 
@@ -238,9 +238,9 @@ class B(A): ...
 
 a: A
 if (lambda x: x.guard())(a):
-    reveal_type(a)  # N: Revealed type is "__main__.B"
+    reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 if (lambda x: x())(a):
-    reveal_type(a)  # N: Revealed type is "__main__.B"
+    reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 [builtins fixtures/tuple.pyi]
 
 
@@ -263,7 +263,7 @@ class B(A): ...
 a: A
 o: object
 assert a.guard(o)
-reveal_type(a)  # N: Revealed type is "__main__.B"
+reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 reveal_type(o)  # N: Revealed type is "object"
 [builtins fixtures/tuple.pyi]
 
@@ -307,7 +307,7 @@ class A:
 class B(A): ...
 a: A
 assert a.guard()
-reveal_type(a)  # N: Revealed type is "__main__.B"
+reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 [builtins fixtures/tuple.pyi]
 
 
@@ -319,7 +319,7 @@ class A:
 class B(A): ...
 a: A
 assert a.guard()
-reveal_type(a)  # N: Revealed type is "__main__.B"
+reveal_type(a)  # N: Revealed type is "__main__.B" (narrowed from "__main__.A")
 [builtins fixtures/tuple.pyi]
 
 
@@ -328,7 +328,7 @@ def guard(a: object) -> 'a is int': ...
 
 a: object
 assert guard(a)
-reveal_type(a)  # N: Revealed type is "int"
+reveal_type(a)  # N: Revealed type is "int" (narrowed from "object")
 [builtins fixtures/tuple.pyi]