render types: render callables in errors

Author: KotlinIsland

mypy/messages.py

@@ -92,6 +92,7 @@
     TypeOfAny,
     TypeStrVisitor,
     TypeType,
+    TypeVarLikeType,
     TypeVarType,
     UnboundType,
     UninhabitedType,
@@ -2153,26 +2154,27 @@ def format_callable_args(
     return ", ".join(arg_strings)
 
 
-def format_type_inner(typ: Type, verbosity: int, fullnames: Optional[Set[str]]) -> str:
+def format_type_inner(
+    typ: Type,
+    verbosity: int,
+    fullnames: Optional[Set[str]],
+    disable_own_scope: Sequence[TypeVarLikeType] = (),
+) -> str:
     """
     Convert a type to a relatively short string suitable for error messages.
 
     Args:
       verbosity: a coarse grained control on the verbosity of the type
       fullnames: a set of names that should be printed in full
+      disable_own_scope: TypeVars to disable scope names
     """
 
     def format(typ: Type) -> str:
-        return format_type_inner(typ, verbosity, fullnames)
+        return format_type_inner(typ, verbosity, fullnames, disable_own_scope)
 
     def format_list(types: Sequence[Type]) -> str:
         return ", ".join(format(typ) for typ in types)
 
-    def format_union(types: Sequence[Type]) -> str:
-        if not mypy.options._based:
-            return format_list(types)
-        return " | ".join(format(typ) for typ in types)
-
     def format_literal_value(typ: LiteralType) -> str:
         if typ.is_enum_literal():
             underlying_type = format(typ.fallback)
@@ -2220,7 +2222,7 @@ def format_literal_value(typ: LiteralType) -> str:
             return f"{base_str}[{format_list(itype.args)}]"
     elif isinstance(typ, TypeVarType):
         # This is similar to non-generic instance types.
-        if mypy.options._based:
+        if mypy.options._based and typ.scopename and typ not in disable_own_scope:
             return f"{typ.name}@{typ.scopename}"
         return typ.name
     elif isinstance(typ, ParamSpecType):
@@ -2297,11 +2299,11 @@ def format_literal_value(typ: LiteralType) -> str:
     elif isinstance(typ, DeletedType):
         return "<deleted>"
     elif isinstance(typ, UninhabitedType):
+        if mypy.options._based:
+            return "Never"
         if typ.is_noreturn:
             return "NoReturn"
         else:
-            if mypy.options._based:
-                return "Never"
             return "<nothing>"
     elif isinstance(typ, TypeType):
         if not mypy.options._based:
@@ -2314,6 +2316,8 @@ def format_literal_value(typ: LiteralType) -> str:
             # return type (this always works).
             return format(TypeType.make_normalized(erase_type(func.items[0].ret_type)))
         elif isinstance(func, CallableType):
+            if func.variables:
+                disable_own_scope = func.variables
             if func.type_guard is not None:
                 return_type = f"TypeGuard[{format(func.type_guard)}]"
             else:
@@ -2332,7 +2336,8 @@ def format_literal_value(typ: LiteralType) -> str:
             )
             if not mypy.options._based:
                 return f"Callable[[{args}], {return_type}]"
-            return f"({args}) -> {return_type}"
+            args = TypeStrVisitor.render_callable_type_params(func, format) + f"({args})"
+            return f"{args} -> {return_type}"
         else:
             # Use a simple representation for function types; proper
             # function types may result in long and difficult-to-read

mypy/types.py

@@ -6,6 +6,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     ClassVar,
     Dict,
     Generator,
@@ -3062,34 +3063,42 @@ def visit_callable_type(self, t: CallableType) -> str:
                 else:
                     s += f" -> {t.ret_type.accept(self)}"
 
-            if t.variables:
-                vs = []
-                for var in t.variables:
-                    if isinstance(var, TypeVarType):
-                        # We reimplement TypeVarType.__repr__ here in order to support id_mapper.
-                        if (
-                            mypy.options._based
-                            and var.scopename
-                            and t.name
-                            and var.scopename != t.name.split(" ")[0]
-                        ):
-                            name = f"{var.name} (from {var.scopename})"
-                        else:
-                            name = var.name
-                        if var.values:
-                            vals = f"({', '.join(val.accept(self) for val in var.values)})"
-                            vs.append(f"{name} in {vals}")
-                        elif not is_named_instance(var.upper_bound, "builtins.object"):
-                            vs.append(f"{name} <: {var.upper_bound.accept(self)}")
-                        else:
-                            vs.append(name)
-                    else:
-                        # For other TypeVarLikeTypes, just use the name
-                        vs.append(var.name)
-                s = f"[{', '.join(vs)}] {s}"
+            s = self.render_callable_type_params(t, lambda x: x.accept(self)) + s
 
             return f"def {s}"
 
+    @staticmethod
+    def render_callable_type_params(t: CallableType, renderer: Callable[[Type], str]) -> str:
+        if not t.variables:
+            return ""
+        vs = []
+        for var in t.variables:
+            if isinstance(var, TypeVarType):
+                # We reimplement TypeVarType.__repr__ here in order to support id_mapper.
+                if (
+                    mypy.options._based
+                    and var.scopename
+                    and t.name
+                    and var.scopename != t.name.split(" ")[0]
+                ):
+                    name = f"{var.name} (from {var.scopename})"
+                else:
+                    name = var.name
+                if var.values:
+                    vals = f"({', '.join(renderer(val) for val in var.values)})"
+                    vs.append(f"{name} in {vals}")
+                elif not is_named_instance(var.upper_bound, "builtins.object"):
+                    if mypy.options._based:
+                        vs.append(f"{name}: {renderer(var.upper_bound)}")
+                    else:
+                        vs.append(f"{name} <: {renderer(var.upper_bound)}")
+                else:
+                    vs.append(name)
+            else:
+                # For other TypeVarLikeTypes, just use the name
+                vs.append(var.name)
+        return f"[{', '.join(vs)}] "
+
     def visit_overloaded(self, t: Overloaded) -> str:
         a = []
         for i in t.items:

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

@@ -14,6 +14,17 @@ class A(Generic[T2]):
 
 reveal_type(A.f)  # N: Revealed type is "def [T2 (from A), T] (self: __main__.A[T2], t: T, t2: T2) -> T | T2"
 reveal_type(A[int]().f)  # N: Revealed type is "def [T] (t: T, t2: int) -> T | int"
+A.f = 1  # E: Cannot assign to a method  [assignment] \
+         # E: Incompatible types in assignment (expression has type "int", variable has type "[T2 (from A), T] (A[T2], T, T2) -> T | T2")  [assignment]
+
+
+[case testGenericFunction]
+from typing import TypeVar
+T = TypeVar("T", bound=int)
+
+def foo(t: T) -> T: ...
+reveal_type(foo)  # N: Revealed type is "def [T: int] (t: T) -> T"
+foo = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "[T: int] (T) -> T")  [assignment]
 
 
 [case testRenderAny]
@@ -47,14 +58,18 @@ from typing import TypeVar
 T = TypeVar("T", bound=int)
 
 def foo(t: T): ...
-reveal_type(foo)  # N: Revealed type is "def[T: int](t: T)"
+reveal_type(foo)  # N: Revealed type is "def [T: int] (t: T)"
 
 
 [case testInferredNever]
-a: bool
-if a: ...
-elif not a: ...
-else:
-    reveal_type(a)  # N: Revealed type is "Never"
-                    # E: Statement is unreachable  [unreachable]
+a: int = []  # E: Incompatible types in assignment (expression has type "list[Never]", variable has type "int")  [assignment]
+reveal_type([])  # N: Revealed type is "list[Never]"
+
 
+[case testNoReturnAsNever]
+from typing import NoReturn
+a: NoReturn = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "Never")  [assignment]
+def b() -> NoReturn: ...
+reveal_type(a)  # N: Revealed type is "Never"
+reveal_type(b)  # N: Revealed type is "def () -> Never"
+b = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "() -> Never")  [assignment]