display overloads & bound method overloads on multiple lines if it's a toplevel type

Summary: for #1219

Reviewed By: rchen152

Differential Revision: D90149768

fbshipit-source-id: 7b5bca99c449a997b7723d2b75936cf23d296433

Author: yangdanny97

conformance/third_party/conformance.exp

@@ -2563,7 +2563,7 @@
       "code": -2,
       "column": 21,
       "concise_description": "`Overloaded9` is not assignable to `FloatArg9`",
-      "description": "`Overloaded9` is not assignable to `FloatArg9`\n  `Overloaded9.__call__` has type `BoundMethod[Overloaded9, Overload[(self: Overloaded9, x: int) -> int, (self: Overloaded9, x: str) -> str]]`, which is not assignable to `BoundMethod[Overloaded9, (self: Overloaded9, x: float) -> float]`, the type of `FloatArg9.__call__`",
+      "description": "`Overloaded9` is not assignable to `FloatArg9`\n  `Overloaded9.__call__` has type `BoundMethod[Overloaded9, Overload[\n  (self: Overloaded9, x: int) -> int\n  (self: Overloaded9, x: str) -> str\n]]`, which is not assignable to `BoundMethod[Overloaded9, (self: Overloaded9, x: float) -> float]`, the type of `FloatArg9.__call__`",
       "line": 273,
       "name": "bad-assignment",
       "severity": "error",
@@ -2574,7 +2574,7 @@
       "code": -2,
       "column": 24,
       "concise_description": "`StrArg10` is not assignable to `Overloaded10`",
-      "description": "`StrArg10` is not assignable to `Overloaded10`\n  `StrArg10.__call__` has type `BoundMethod[StrArg10, (self: StrArg10, x: str) -> complex]`, which is not assignable to `BoundMethod[StrArg10, Overload[(self: StrArg10, x: int, y: str) -> float, (self: StrArg10, x: str) -> complex]]`, the type of `Overloaded10.__call__`",
+      "description": "`StrArg10` is not assignable to `Overloaded10`\n  `StrArg10.__call__` has type `BoundMethod[StrArg10, (self: StrArg10, x: str) -> complex]`, which is not assignable to `BoundMethod[StrArg10, Overload[\n  (self: StrArg10, x: int, y: str) -> float\n  (self: StrArg10, x: str) -> complex\n]]`, the type of `Overloaded10.__call__`",
       "line": 297,
       "name": "bad-assignment",
       "severity": "error",

crates/pyrefly_types/src/display.rs

@@ -435,13 +435,25 @@ impl<'a> TypeDisplayContext<'a> {
                     }
                     Ok(())
                 } else {
-                    output.write_str("Overload[")?;
+                    if is_toplevel {
+                        output.write_str("Overload[\n  ")?;
+                    } else {
+                        output.write_str("Overload[")?;
+                    }
                     self.fmt_helper_generic(&overload.signatures.first().as_type(), false, output)?;
                     for sig in overload.signatures.iter().skip(1) {
-                        output.write_str(", ")?;
+                        if is_toplevel {
+                            output.write_str("\n  ")?;
+                        } else {
+                            output.write_str(", ")?;
+                        }
                         self.fmt_helper_generic(&sig.as_type(), false, output)?;
                     }
-                    output.write_str("]")
+                    if is_toplevel {
+                        output.write_str("\n]")
+                    } else {
+                        output.write_str("]")
+                    }
                 }
             }
             Type::ParamSpecValue(x) => {
@@ -519,7 +531,7 @@ impl<'a> TypeDisplayContext<'a> {
                         output.write_str("BoundMethod[")?;
                         self.fmt_helper_generic(obj, false, output)?;
                         output.write_str(", ")?;
-                        self.fmt_helper_generic(&func.clone().as_type(), false, output)?;
+                        self.fmt_helper_generic(&func.clone().as_type(), is_toplevel, output)?;
                         output.write_str("]")
                     }
                 }
@@ -1652,11 +1664,19 @@ pub mod tests {
             metadata: Box::new(sig1.metadata.clone()),
         });
 
-        // Test compact display mode (non-hover)
+        // Test compact display mode as toplevel type (non-hover)
         let ctx = TypeDisplayContext::new(&[&overload]);
         assert_eq!(
             ctx.display(&overload).to_string(),
-            "Overload[(x: Any) -> None, [T](x: Any, y: Any) -> None]"
+            "Overload[\n  (x: Any) -> None\n  [T](x: Any, y: Any) -> None\n]"
+        );
+
+        // Test compact display mode as non-toplevel type (non-hover)
+        let type_form_of_overload = Type::type_form(overload.clone());
+        let ctx = TypeDisplayContext::new(&[&type_form_of_overload]);
+        assert_eq!(
+            ctx.display(&type_form_of_overload).to_string(),
+            "type[Overload[(x: Any) -> None, [T](x: Any, y: Any) -> None]]"
         );
 
         // Test hover display mode (with @overload decorators)
@@ -1691,11 +1711,19 @@ def overloaded_func[T](
             }),
         }));
 
-        // Test compact display mode (non-hover)
+        // Test compact display mode as toplevel type (non-hover)
         let ctx = TypeDisplayContext::new(&[&bound_method_overload]);
         assert_eq!(
             ctx.display(&bound_method_overload).to_string(),
-            "BoundMethod[Any, Overload[(x: Any) -> None, [T](x: Any, y: Any) -> None]]"
+            "BoundMethod[Any, Overload[\n  (x: Any) -> None\n  [T](x: Any, y: Any) -> None\n]]"
+        );
+
+        // Test compact display mode as non-toplevel type (non-hover)
+        let type_form_of_bound_method_overload = Type::type_form(bound_method_overload.clone());
+        let ctx = TypeDisplayContext::new(&[&type_form_of_bound_method_overload]);
+        assert_eq!(
+            ctx.display(&type_form_of_bound_method_overload).to_string(),
+            "type[BoundMethod[Any, Overload[(x: Any) -> None, [T](x: Any, y: Any) -> None]]]"
         );
 
         // Test hover display mode (with @overload decorators)

pyrefly/lib/test/attributes.rs

@@ -1411,7 +1411,7 @@ class A[T]:
     @overload
     def f(self, x: T | None) -> T: ...
     def f(self, x=None) -> Any: ...
-reveal_type(A.f) # E: revealed type: Overload[[T](self: A[T]) -> T, [T](self: A[T], x: T | None) -> T]
+reveal_type(A.f) # E: revealed type: Overload[\n  [T](self: A[T]) -> T\n  [T](self: A[T], x: T | None) -> T\n]
 assert_type(A.f(A[int]()), int)
     "#,
 );
@@ -1429,7 +1429,7 @@ class A[T]:
     def f(x: T) -> T: ...
     @staticmethod
     def f(x = None) -> Any: ...
-reveal_type(A.f) # E: revealed type: Overload[(x: None = ...) -> None, [T](x: T) -> T]
+reveal_type(A.f) # E: revealed type: Overload[\n  (x: None = ...) -> None\n  [T](x: T) -> T\n]
 assert_type(A.f(), None)
 assert_type(A.f(0), int)
     "#,
@@ -1738,7 +1738,7 @@ def get_type_t[T]() -> type[T]:
     return cast(type[T], 0)
 def foo[T](x: type[T]):
     # mypy reveals the same thing we do (the type of `type.__new__`), while pyright reveals `Unknown`.
-    reveal_type(get_type_t().__new__)  # E: Overload[[Self@type](cls: type[Self@type], o: object, /) -> type, [Self](cls: type[Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], /, **kwds: Any) -> Self]
+    reveal_type(get_type_t().__new__)  # E: Overload[\n  [Self@type](cls: type[Self@type], o: object, /) -> type\n  [Self](cls: type[Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], /, **kwds: Any) -> Self\n]
     "#,
 );
 

pyrefly/lib/test/lsp/hover_type.rs

@@ -130,7 +130,7 @@ async def test(vals: dict[int, str]) -> None:
 
     for k in vals.keys(): # 2
         k
-        
+
     for v in vals.values(): # 3
         v
 "#;
@@ -444,7 +444,10 @@ Hover Result: `(a: int, b: bool) -> str`
 
 15 | overloaded_func(False)
        ^
-Hover Result: `Overload[(a: str) -> bool, (a: int, b: bool) -> str]`
+Hover Result: `Overload[
+  (a: str) -> bool
+  (a: int, b: bool) -> str
+]`
 "#
         .trim(),
         report.trim(),
@@ -486,7 +489,10 @@ Hover Result: `(self: Foo, a: int, b: bool) -> str`
 
 17 | foo.overloaded_meth(False)
              ^
-Hover Result: `BoundMethod[Foo, Overload[(self: Foo, a: str) -> bool, (self: Foo, a: int, b: bool) -> str]]`
+Hover Result: `BoundMethod[Foo, Overload[
+  (self: Foo, a: str) -> bool
+  (self: Foo, a: int, b: bool) -> str
+]]`
 "#
         .trim(),
         report.trim(),