Attach signature to BindingInfo (#1102)

Unifies the signature information shown in the holes panel between type
and term bindings.
This is achieved by replacing the `type` and `definition` fields with
`signature` and `signatureHtml` fields and implementing a separate
pretty-printer for signatures.

Author: timsueberkrueb

effekt/jvm/src/test/scala/effekt/LSPTests.scala

@@ -1421,10 +1421,10 @@ class LSPTests extends FunSuite {
           qualifier = List(),
           name = "x",
           origin = BindingOrigin.Defined,
-          `type` = Some(
-            "Int"
+          signature = Some(
+            "x: Int"
           ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">Int</span>")
+          signatureHtml = Some("<span class=\"effekt-ident camel-case\">x</span>: <span class=\"effekt-ident pascal-case\">Int</span>"),
         )
       )
 
@@ -1433,26 +1433,32 @@ class LSPTests extends FunSuite {
           qualifier = List(),
           name = "bar",
           origin = BindingOrigin.Defined,
-          `type` = Some(
-            "String => Int"
+          signature = Some(
+            "def bar(x: String): Int / {}"
           ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">String</span> =&gt; <span class=\"effekt-ident pascal-case\">Int</span>"),
+          signatureHtml = Some(
+            "<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident camel-case\">bar</span>(<span class=\"effekt-ident camel-case\">x</span>: <span class=\"effekt-ident pascal-case\">String</span>): <span class=\"effekt-ident pascal-case\">Int</span> / {}"
+          )
         ),
         TermBinding(
           qualifier = List(),
           name = "foo",
           origin = BindingOrigin.Defined,
-          `type` = Some(
-            "Int => Bool"
+          signature = Some(
+            "def foo(x: Int): Bool / {}"
+          ),
+          signatureHtml = Some(
+            "<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident camel-case\">foo</span>(<span class=\"effekt-ident camel-case\">x</span>: <span class=\"effekt-ident pascal-case\">Int</span>): <span class=\"effekt-ident pascal-case\">Bool</span> / {}"
           ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">Int</span> =&gt; <span class=\"effekt-ident pascal-case\">Bool</span>"),
         ),
         TypeBinding(
           qualifier = Nil,
           name = "MyInt",
           origin = BindingOrigin.Defined,
-          definition = "type MyInt = Int",
-          definitionHtml = "<span class=\"effekt-keyword\">type</span> <span class=\"effekt-ident pascal-case\">MyInt</span> = <span class=\"effekt-ident pascal-case\">Int</span>",
+          signature = Some("type MyInt"),
+          signatureHtml = Some(
+            "<span class=\"effekt-keyword\">type</span> <span class=\"effekt-ident pascal-case\">MyInt</span>"
+          ),
         )
       )
 
@@ -1574,8 +1580,8 @@ class LSPTests extends FunSuite {
           qualifier = List(),
           name = "bar",
           origin = BindingOrigin.Defined,
-          `type` = Some("() => Nothing"),
-          typeHtml = Some("() =&gt; <span class=\"effekt-ident pascal-case\">Nothing</span>")
+          signature = Some("def bar(): Nothing / {}"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident camel-case\">bar</span>(): <span class=\"effekt-ident pascal-case\">Nothing</span> / {}"),
         )
       )
 
@@ -1604,8 +1610,8 @@ class LSPTests extends FunSuite {
             qualifier = List(),
             name = "x",
             origin = BindingOrigin.Defined,
-            `type` = Some("Int"),
-            typeHtml = Some("<span class=\"effekt-ident pascal-case\">Int</span>")
+            signature = Some("x: Int"),
+            signatureHtml = None,
           )
         ),
         outer = Some(ScopeInfo(
@@ -1620,8 +1626,8 @@ class LSPTests extends FunSuite {
                 qualifier = List(),
                 name = "MyInt",
                 origin = BindingOrigin.Defined,
-                definition = "type MyInt = Int",
-                definitionHtml = "<span class=\"effekt-keyword\">type</span> <span class=\"effekt-ident pascal-case\">MyInt</span> = <span class=\"effekt-ident pascal-case\">Int</span>"
+                signature = Some("type MyInt"),
+                signatureHtml = None,
               )),
             outer = None
           ))
@@ -1654,8 +1660,7 @@ class LSPTests extends FunSuite {
         |        "qualifier": [],
         |        "name": "x",
         |        "origin": "Defined",
-        |        "type": "Int",
-        |        "typeHtml": "<span class=\"effekt-ident pascal-case\">Int</span>",
+        |        "signature": "x: Int",
         |        "kind": "Term"
         |      }
         |    ],
@@ -1670,8 +1675,7 @@ class LSPTests extends FunSuite {
         |            "qualifier": [],
         |            "name": "MyInt",
         |            "origin": "Defined",
-        |            "definition": "type MyInt = Int",
-        |            "definitionHtml": "<span class=\"effekt-keyword\">type</span> <span class=\"effekt-ident pascal-case\">MyInt</span> = <span class=\"effekt-ident pascal-case\">Int</span>",
+        |            "signature": "type MyInt",
         |            "kind": "Type"
         |          }
         |        ]
@@ -1929,97 +1933,77 @@ class LSPTests extends FunSuite {
           qualifier = Nil,
           name = "Foo1",
           origin = "Defined",
-          definition = """type Foo1 {
-  def Foo1(theField: String): Foo1 / {}
-}""",
-          definitionHtml = """<span class="effekt-keyword">type</span> <span class="effekt-ident pascal-case">Foo1</span> {
-  <span class="effekt-keyword">def</span> <span class="effekt-ident pascal-case">Foo1</span>(<span class="effekt-ident camel-case">theField</span>: <span class="effekt-ident pascal-case">String</span>): <span class="effekt-ident pascal-case">Foo1</span> / {}
-}""",
+          signature = Some("type Foo1"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">type</span> <span class=\"effekt-ident pascal-case\">Foo1</span>"),
           kind = "Type"
         ),
         TermBinding(
           qualifier = Nil,
           name = "Foo1",
           origin = "Defined",
-          `type` = Some(
-            value = "String => Foo1"
+          signature = Some(
+            "def Foo1(theField: String): Foo1 / {}"
           ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">String</span> =&gt; <span class=\"effekt-ident pascal-case\">Foo1</span>"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident pascal-case\">Foo1</span>(<span class=\"effekt-ident camel-case\">theField</span>: <span class=\"effekt-ident pascal-case\">String</span>): <span class=\"effekt-ident pascal-case\">Foo1</span> / {}"),
           kind = "Term",
         ),
         TermBinding(
           qualifier = Nil,
           name = "theField",
           origin = "Defined",
-          `type` = Some(
-            value = "Foo1 => String"
+          signature = Some(
+            "def theField(Foo1: Foo1): String / {}"
           ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">Foo1</span> =&gt; <span class=\"effekt-ident pascal-case\">String</span>"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident camel-case\">theField</span>(<span class=\"effekt-ident pascal-case\">Foo1</span>: <span class=\"effekt-ident pascal-case\">Foo1</span>): <span class=\"effekt-ident pascal-case\">String</span> / {}"),
           kind = "Term",
         ),
         TypeBinding(
           qualifier = Nil,
           name = "Foo2",
           origin = "Defined",
-          definition = """type Foo2 {
-  def Foo2(theField: String): Foo2 / {}
-}""",
-          definitionHtml = """<span class="effekt-keyword">type</span> <span class="effekt-ident pascal-case">Foo2</span> {
-  <span class="effekt-keyword">def</span> <span class="effekt-ident pascal-case">Foo2</span>(<span class="effekt-ident camel-case">theField</span>: <span class="effekt-ident pascal-case">String</span>): <span class="effekt-ident pascal-case">Foo2</span> / {}
-}""",
+          signature = Some("type Foo2"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">type</span> <span class=\"effekt-ident pascal-case\">Foo2</span>"),
           kind = "Type"
         ),
         TermBinding(
           qualifier = Nil,
           name = "Foo2",
           origin = "Defined",
-          `type` = Some(
-            value = "String => Foo2"
-          ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">String</span> =&gt; <span class=\"effekt-ident pascal-case\">Foo2</span>"),
-          kind = "Term",
+          signature = Some("def Foo2(theField: String): Foo2 / {}"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident pascal-case\">Foo2</span>(<span class=\"effekt-ident camel-case\">theField</span>: <span class=\"effekt-ident pascal-case\">String</span>): <span class=\"effekt-ident pascal-case\">Foo2</span> / {}"),
+          kind = "Term"
         ),
         TermBinding(
           qualifier = Nil,
           name = "theField",
           origin = "Defined",
-          `type` = Some(
-            value = "Foo2 => String"
-          ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">Foo2</span> =&gt; <span class=\"effekt-ident pascal-case\">String</span>"),
-          kind = "Term",
+          signature = Some("def theField(Foo2: Foo2): String / {}"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident camel-case\">theField</span>(<span class=\"effekt-ident pascal-case\">Foo2</span>: <span class=\"effekt-ident pascal-case\">Foo2</span>): <span class=\"effekt-ident pascal-case\">String</span> / {}"),
+          kind = "Term"
         ),
         TypeBinding(
           qualifier = Nil,
           name = "Bar",
           origin = "Defined",
-          definition = """type Bar {
-  def Bar(theField: Int): Bar / {}
-}""",
-          definitionHtml = """<span class="effekt-keyword">type</span> <span class="effekt-ident pascal-case">Bar</span> {
-  <span class="effekt-keyword">def</span> <span class="effekt-ident pascal-case">Bar</span>(<span class="effekt-ident camel-case">theField</span>: <span class="effekt-ident pascal-case">Int</span>): <span class="effekt-ident pascal-case">Bar</span> / {}
-}""",
+          signature = Some("type Bar"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">type</span> <span class=\"effekt-ident pascal-case\">Bar</span>"),
           kind = "Type"
         ),
         TermBinding(
           qualifier = Nil,
           name = "Bar",
           origin = "Defined",
-          `type` = Some(
-            value = "Int => Bar"
-          ),
-          typeHtml = Some("<span class=\"effekt-ident pascal-case\">Int</span> =&gt; <span class=\"effekt-ident pascal-case\">Bar</span>"),
-          kind = "Term",
+          signature = Some("def Bar(theField: Int): Bar / {}"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident pascal-case\">Bar</span>(<span class=\"effekt-ident camel-case\">theField</span>: <span class=\"effekt-ident pascal-case\">Int</span>): <span class=\"effekt-ident pascal-case\">Bar</span> / {}"),
+          kind = "Term"
         ),
         TermBinding(
           qualifier = Nil,
           name = "main",
           origin = "Defined",
-          `type` = Some(
-            value = "() => Nothing"
-          ),
-          typeHtml = Some("() =&gt; <span class=\"effekt-ident pascal-case\">Nothing</span>"),
-          kind = "Term",
+          signature = Some("def main(): Nothing / {}"),
+          signatureHtml = Some("<span class=\"effekt-keyword\">def</span> <span class=\"effekt-ident camel-case\">main</span>(): <span class=\"effekt-ident pascal-case\">Nothing</span> / {}"),
+          kind = "Term"
         )
       )
 

effekt/shared/src/main/scala/effekt/Intelligence.scala

@@ -189,7 +189,7 @@ trait Intelligence {
     }
 
   def allBindings(origin: String, bindings: Bindings, path: List[String] = Nil)(using C: Context): List[BindingInfo] =
-    val symbols = allSymbols(origin, bindings, path)
+    val symbols = allSymbols(origin, bindings, path).distinctBy(s => s._3)
 
     val sorted = if (origin == BindingOrigin.Imported) {
       symbols.sortBy(_._1.toLowerCase())
@@ -200,24 +200,28 @@ trait Intelligence {
       })
     }
 
-    sorted.flatMap((name, path, sym) => sym match {
+    def symbolToBindingInfos(name: String, path: List[String], sym: TypeSymbol | TermSymbol)(using C: Context): List[BindingInfo] =
       // TODO this is extremely hacky, printing is not defined for all types at the moment
-      case sym: TypeSymbol => try {
-        val definition = DeclPrinter(sym)
-        val definitionHtml = HtmlHighlight(definition)
-        Some(TypeBinding(path, name, origin, definition, definitionHtml))
-      } catch { case e => None }
-      case sym: ValueSymbol => {
-        val `type` = C.valueTypeOption(sym).map(t => pp"${t}")
-        val typeHtml = `type`.map(HtmlHighlight(_))
-        Some(TermBinding(path, name, origin, `type`, typeHtml))
+      val signature = try { Some(SignaturePrinter(sym)) } catch { case e: Throwable => None }
+      val signatureHtml = signature.map(sig => HtmlHighlight(sig))
+      val out = sym match {
+        case sym: TypeSymbol => List(TypeBinding(path, name, origin, signature, signatureHtml))
+        case sym: ValueSymbol => List(TermBinding(path, name, origin, signature, signatureHtml))
+        case sym: BlockSymbol => List(TermBinding(path, name, origin, signature, signatureHtml))
       }
-      case sym: BlockSymbol => {
-        val `type` = C.blockTypeOption(sym).map(t => pp"${t}")
-        val typeHtml = `type`.map(HtmlHighlight(_))
-        Some(TermBinding(path, name, origin, `type`, typeHtml))
+      sym match {
+        case Interface(name, tparams, ops, decl) if !(ops.length == 1 && ops.head.name.name == name.name) => {
+          val opsInfos = ops.map { op =>
+            val signature = Some(SignaturePrinter(op))
+            val signatureHtml = signature.map(sig => HtmlHighlight(sig))
+            TermBinding(path, op.name.name, origin, signature, signatureHtml)
+          }
+          out ++ opsInfos
+        }
+        case _ => out
       }
-    }).toList
+
+    sorted.flatMap(symbolToBindingInfos).toList
 
   def allSymbols(origin: String, bindings: Bindings, path: List[String] = Nil)(using C: Context): Array[(String, List[String], TypeSymbol | TermSymbol)] = {
     bindings.types.toArray.map((name, sym) => (name, path, sym))
@@ -464,23 +468,25 @@ object Intelligence {
     val qualifier: List[String]
     val name: String
     val origin: String
+    val signature: Option[String]
+    val signatureHtml: Option[String]
     val kind: String
   }
 
   case class TermBinding(
     qualifier: List[String],
     name: String,
     origin: String,
-    `type`: Option[String],
-    typeHtml: Option[String],
+    signature: Option[String] = None,
+    signatureHtml: Option[String],
     kind: String = BindingKind.Term
   ) extends BindingInfo
   case class TypeBinding(
     qualifier: List[String],
     name: String,
     origin: String,
-    definition: String,
-    definitionHtml: String,
+    signature: Option[String] = None,
+    signatureHtml: Option[String],
     kind: String = BindingKind.Type
   ) extends BindingInfo