Visibility Modifiers (#1094)

This PR reorganizes parsing of modifiers on declaraionts, which are now
grouped in `Info`. It also adds one new modifier `private`, which is
parsed, but then ignored.

Author: b-studios

effekt/jvm/src/main/scala/effekt/Repl.scala

@@ -315,7 +315,7 @@ class Repl(driver: Driver) extends REPL[Tree, EffektConfig, EffektError] {
       val fullSpan = Span(source, 0, source.content.length, origin = Origin.Synthesized)
       ModuleDecl("interactive", includes,
         definitions :+ FunDef(IdDef("main", fakeSpan), Many.empty(fakeSpan), Many.empty(fakeSpan), Many.empty(fakeSpan), Maybe.None(fakeSpan),
-          body, None, fullSpan), None, fullSpan)
+          body, Info.empty(fakeSpan), fullSpan), None, fullSpan)
     }
 
     def makeEval(source: Source, expr: Term): ModuleDecl = {

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

@@ -48,14 +48,14 @@ class LSPTests extends FunSuite {
   def withClientAndServer(testBlock: (MockLanguageClient, Server) => Unit): Unit = {
     withClientAndServer(true)(testBlock)
   }
-  
+
   /** Normalize the output of the IR by replacing the generated identifiers and stripping all whitespace
    */
   def normalizeIRString(ir: String): String = {
     ir.replaceAll("_\\d+", "_whatever")
       .replaceAll("\\s+", "")
   }
-  
+
   def assertIREquals(ir: String, expected: String): Unit = {
     val normalizedIR = normalizeIRString(ir)
     val normalizedExpected = normalizeIRString(expected)
@@ -1222,7 +1222,18 @@ class LSPTests extends FunSuite {
              |        ),
              |        Span(StringSource(def main() = <>, file://test.effekt), 13, 15, Real())
              |      ),
-             |      None(),
+             |      Info(
+             |        None(),
+             |        Maybe(
+             |          None(),
+             |          Span(StringSource(def main() = <>, file://test.effekt), 0, 0, Real())
+             |        ),
+             |        Maybe(
+             |          None(),
+             |          Span(StringSource(def main() = <>, file://test.effekt), 0, 0, Real())
+             |        ),
+             |        None()
+             |      ),
              |      Span(StringSource(def main() = <>, file://test.effekt), 0, 15, Real())
              |    )
              |  ),
@@ -1410,7 +1421,7 @@ class LSPTests extends FunSuite {
       assertEquals(receivedHoles.head.holes.length, 1)
     }
   }
-  
+
   test("Server publishes hole id for nested defs") {
     withClientAndServer { (client, server) =>
       val source =

effekt/jvm/src/test/scala/effekt/ParserTests.scala

@@ -144,6 +144,9 @@ class ParserTests extends munit.FunSuite {
   def parseExternDef(input: String, positions: Positions = new Positions())(using munit.Location): Def =
     parse(input, _.externDef())
 
+  def parseInfo(input: String, positions: Positions = new Positions())(using munit.Location): Info =
+    parse(input, _.info(parseCaptures = true))
+
   // Custom asserts
   //
   //
@@ -997,7 +1000,8 @@ class ParserTests extends munit.FunSuite {
           IdDef("foo", Span(source, pos(0), pos(1))),
           None,
           Var(IdRef(Nil, "f", Span(source, pos(2), pos(3))), Span(source, pos(2), pos(3))),
-          None, Span(source, 0, pos.last)))
+          Info.empty(Span(source, 0, 0)),
+          Span(source, 0, pos.last)))
     }
 
     parseDefinition(
@@ -1079,6 +1083,17 @@ class ParserTests extends munit.FunSuite {
     assertEquals(funDef.ret.span, Span(source, pos(1), pos(1)))
   }
 
+  test("Function definition with comment") {
+    val (source, pos) =
+      raw"""/// Calculate the answer to the ultimate question of life, the universe, and everything
+           |def calculate() = 42
+           |""".sourceAndPositions
+
+    val definition = parseDefinition(source.content)
+
+    assertEquals(definition.doc, Some(" Calculate the answer to the ultimate question of life, the universe, and everything"))
+  }
+
   test("Function definition with whitespaces instead of return type") {
     val (source, pos) =
       raw"""def foo{b: => Unit / bar}      = <>
@@ -1132,6 +1147,62 @@ class ParserTests extends munit.FunSuite {
     assertEquals(valDef.span, span)
   }
 
+  test("Declaration info with capture set") {
+    val (source, pos) =
+      raw"""/// Some doc comment
+           |private extern {a, b, c}
+           |↑      ↑↑     ↑↑        ↑
+           |""".sourceAndPositions
+
+    parseInfo(source.content) match {
+      case Info(
+          Some(doc),
+          isPrivate,
+          isExtern,
+          Some(CaptureSet(captures, Span(_, captFrom, captTo, _)))) =>
+
+        assertEquals(doc, " Some doc comment")
+        assertEquals(isPrivate, Maybe(Some(()), Span(source, pos(0), pos(1))))
+        assertEquals(isExtern, Maybe(Some(()), Span(source, pos(2), pos(3))))
+        assertEquals(captures.map(_.name), List("a", "b", "c"))
+        assertEquals(captFrom, pos(4))
+        assertEquals(captTo, pos(5))
+
+      case info => fail(s"Wrong info: ${info}")
+    }
+  }
+
+  test("Only private") {
+    val (source, pos) =
+      raw"""/// Some doc comment
+           |private
+           |↑      ↑
+           |""".sourceAndPositions
+
+    parseInfo(source.content) match {
+      case Info(doc, isPrivate, isExtern, externCapture) =>
+
+        assertEquals(doc, Some(" Some doc comment"))
+        assertEquals(isPrivate, Maybe(Some(()), Span(source, pos(0), pos(1))))
+        assertEquals(isExtern, Maybe(None, Span(source, pos(1), pos(1))))
+        assertEquals(externCapture, None)
+    }
+  }
+
+  test("Only doc comment") {
+    val (source, pos) =
+      raw"""/// Some doc comment
+           |                    ↑
+           |""".sourceAndPositions
+
+    parseInfo(source.content) match {
+      case Info(doc, isPrivate, isExtern, externCapture) =>
+        assertEquals(doc, Some(" Some doc comment"))
+        assertEquals(isPrivate, Maybe(None, Span(source, pos(0), pos(0))))
+        assertEquals(isExtern, Maybe(None, Span(source, pos(0), pos(0))))
+        assertEquals(externCapture, None)
+    }
+  }
 
   test("Region definition parses with correct span") {
     val (source, span) =

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

@@ -125,6 +125,7 @@ trait Intelligence {
         p.productElementNames.zip(p.productIterator)
           .collectFirst {
             case ("doc", Some(s: String)) => s
+            case ("info", source.Info(Some(s: String), _, _, _)) => s
           }
       case _ => None
   }

effekt/shared/src/main/scala/effekt/Lexer.scala

@@ -130,11 +130,7 @@ enum TokenKind {
   case `fun`
   case `match`
   case `def`
-  case `module`
-  case `import`
-  case `export`
   case `extern`
-  case `include`
   case `record`
   case `box`
   case `unbox`
@@ -146,6 +142,12 @@ enum TokenKind {
   case `is`
   case `namespace`
   case `pure`
+
+  case `module`
+  case `import`
+  case `export`
+  case `include`
+  case `private`
 }
 
 object TokenKind {
@@ -178,7 +180,7 @@ object TokenKind {
     `let`, `true`, `false`, `val`, `var`, `if`, `else`, `while`, `type`, `effect`, `interface`,
     `try`, `with`, `case`, `do`, `fun`, `match`, `def`, `module`, `import`, `export`, `extern`,
     `include`, `record`, `box`, `unbox`, `return`, `region`, `resource`, `new`, `and`, `is`,
-    `namespace`, `pure`
+    `namespace`, `pure`, `private`
   )
 
   val keywordMap: immutable.HashMap[String, TokenKind] =