Multiple Return Values

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

@@ -108,7 +108,7 @@ class Repl(driver: Driver) extends REPL[Tree, EffektConfig, EffektError] {
       runFrontend(StringSource(""), module.make(UnitLit()), config) { cu =>
         module.definitions.foreach {
           case u: Def =>
-            outputCode(DeclPrinter(context.symbolOf(u)), config)
+            outputCode(DeclPrinter(List(u.id.symbol)), config)
         }
       }
     }
@@ -123,7 +123,7 @@ class Repl(driver: Driver) extends REPL[Tree, EffektConfig, EffektError] {
             // TODO this is a bit ad-hoc
             val mainSym = mod.terms("main").head
             val mainTpe = context.functionTypeOf(mainSym)
-            output.emitln(pp"${mainTpe.result}")
+            output.emitln(pp"${mainTpe.result.map{ t => pp"$t"}.mkString(", ")}")
           }
 
         case Success(other, _) =>
@@ -199,14 +199,14 @@ class Repl(driver: Driver) extends REPL[Tree, EffektConfig, EffektError] {
         output.emitln(s"Imported Types\n==============")
         cu.types.toList.sortBy { case (n, _) => n }.collect {
           case (name, sym) if !sym.isSynthetic =>
-            outputCode(DeclPrinter(sym), config)
+            outputCode(DeclPrinter(List(sym)), config)
         }
         output.emitln(s"\nImported Functions\n==================")
         cu.terms.toList.sortBy { case (n, _) => n }.foreach {
           case (name, syms) =>
             syms.collect {
               case sym if !sym.isSynthetic =>
-                outputCode(DeclPrinter(sym), config)
+                outputCode(DeclPrinter(List(sym)), config)
             }
         }
         module = extendedImports
@@ -220,15 +220,15 @@ class Repl(driver: Driver) extends REPL[Tree, EffektConfig, EffektError] {
         module = extendedDefs
 
         // try to find the symbol for the def to print the type
-        (context.symbolOption(d.id) match {
+        context.symbolOption(d.id) match {
           case Some(v: ValueSymbol) =>
-            Some(context.valueTypeOf(v))
+            Some(v, context.valueTypeOf(v))
           case Some(b: BlockSymbol) =>
-            Some(context.blockTypeOf(b))
+            Some(b, context.blockTypeOf(b))
           case t =>
             None
-        }) map { tpe =>
-          outputCode(pp"${d.id}: ${tpe}", config)
+        } map { case (id, tpe) =>
+          outputCode(pp"${id}: ${tpe}", config)
         }
       }
 
@@ -308,7 +308,7 @@ class Repl(driver: Driver) extends REPL[Tree, EffektConfig, EffektError] {
      */
     def make(expr: Term): ModuleDecl = {
 
-      val body = Return(expr)
+      val body = Return(List(expr))
 
       ModuleDecl("interactive", imports,
         definitions :+ FunDef(IdDef("main"), Nil, Nil, Nil, None,

effekt/jvm/src/main/scala/effekt/Server.scala

@@ -9,8 +9,7 @@ import effekt.util.messages.EffektError
 
 import kiama.util.{ Filenames, Position, Services, Source }
 import kiama.output.PrettyPrinterTypes.Document
-
-import org.eclipse.lsp4j.{ Diagnostic, DocumentSymbol, SymbolKind, ExecuteCommandParams }
+import org.eclipse.lsp4j.{Diagnostic, DocumentSymbol, ExecuteCommandParams, SymbolKind}
 
 /**
  * effekt.Intelligence <--- gathers information -- LSPServer --- provides LSP interface ---> kiama.Server
@@ -201,15 +200,19 @@ trait LSPServer extends kiama.util.Server[Tree, EffektConfig, EffektError] with
    * Also, it is necessary to be able to manually set the code action kind (and register them on startup).
    * This way, we can use custom kinds like `refactor.closehole` that can be mapped to keys.
    */
-  def inferEffectsAction(fun: FunDef)(using C: Context): Option[TreeAction] = for {
+  def inferEffectsAction(fun: FunDef)(using C: Context): Option[TreeAction] =
+    val symbol = fun.symbol
+    for {
     // the inferred type
     (tpe, eff) <- C.inferredTypeAndEffectOption(fun)
     // the annotated type
     ann = for {
-      result <- fun.symbol.annotatedResult
-      effects <- fun.symbol.annotatedEffects
+      result <- symbol.annotatedResult
+      effects <- symbol.annotatedEffects
     } yield (result, effects)
-    if ann.map { needsUpdate(_, (tpe, eff)) }.getOrElse(true)
+    if ann.map {
+      (y, eff1) => needsUpdate((y, eff1), (tpe, eff))
+    }.getOrElse(true)
     res <- CodeAction("Update return type with inferred effects", fun.ret, s": $tpe / $eff")
   } yield res
 
@@ -231,10 +234,16 @@ trait LSPServer extends kiama.util.Server[Tree, EffektConfig, EffektError] with
     }
   } yield res
 
-  def needsUpdate(annotated: (ValueType, Effects), inferred: (ValueType, Effects))(using Context): Boolean = {
-    val (tpe1, effs1) = annotated
-    val (tpe2, effs2) = inferred
-    tpe1 != tpe2 || effs1 != effs2
+  def needsUpdate(annotated: (List[ValueType], Effects), inferred: (List[ValueType], Effects))(using Context): Boolean = {
+    val (tpes1, effs1) = annotated
+    val (tpes2, effs2) = inferred
+
+    val differentArity = tpes1.size != tpes2.size
+    val differentEffects = effs1 != effs2
+
+    def differentTypes = (tpes1 zip tpes2).forall { case (tpe1, tpe2) => tpe1 != tpe2 }
+
+    differentArity || differentEffects || differentTypes
   }
 
   case class CaptureInfo(location: Location, captureText: String)

effekt/jvm/src/test/scala/effekt/PolymorphismBoxingTests.scala

@@ -72,14 +72,14 @@ abstract class AbstractPolymorphismBoxingTests extends munit.FunSuite {
     }
 
     override def stmt: PartialFunction[Stmt, Stmt] = {
-      case core.Scope(definitions, rest) => withBindings(definitions.map{
-          case core.Definition.Def(id, _) => id
-          case core.Definition.Let(id, _) => id
+      case core.Scope(definitions, rest) => withBindings(definitions.flatMap{
+          case core.Definition.Def(id, _) => List(id)
+          case core.Definition.Let(ids, _) => ids
         }){
         core.Scope(definitions map rewrite, rewrite(rest))
       }
-      case core.Val(id, binding, body) => withBinding(id){
-        core.Val(rewrite(id), rewrite(binding), rewrite(body))
+      case core.Val(ids, binding, body) => withBindings(ids){
+        core.Val(ids.map(rewrite), rewrite(binding), rewrite(body))
       }
       case core.State(id, init, reg, body) => withBinding(id){
         core.State(rewrite(id), rewrite(init), rewrite(reg), rewrite(body))

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

@@ -122,10 +122,10 @@ trait Intelligence {
   def getInfoOf(sym: Symbol)(implicit C: Context): Option[SymbolInfo] = PartialFunction.condOpt(resolveCallTarget(sym)) {
 
     case b: ExternFunction =>
-      SymbolInfo(b, "External function definition", Some(DeclPrinter(b)), None)
+      SymbolInfo(b, "External function definition", Some(DeclPrinter(List(b))), None)
 
     case f: UserFunction if C.functionTypeOption(f).isDefined =>
-      SymbolInfo(f, "Function", Some(DeclPrinter(f)), None)
+      SymbolInfo(f, "Function", Some(DeclPrinter(List(f))), None)
 
     case f: Operation =>
       val ex =
@@ -147,30 +147,30 @@ trait Intelligence {
              |handled by the handler. This is important when considering higher-order functions.
              |""".stripMargin
 
-      SymbolInfo(f, "Effect operation", Some(DeclPrinter(f)), Some(ex))
+      SymbolInfo(f, "Effect operation", Some(DeclPrinter(List(f))), Some(ex))
 
     case f: EffectAlias =>
-      SymbolInfo(f, "Effect alias", Some(DeclPrinter(f)), None)
+      SymbolInfo(f, "Effect alias", Some(DeclPrinter(List(f))), None)
 
     case t: TypeAlias =>
-      SymbolInfo(t, "Type alias", Some(DeclPrinter(t)), None)
+      SymbolInfo(t, "Type alias", Some(DeclPrinter(List(t))), None)
 
     case t: ExternType =>
-      SymbolInfo(t, "External type definition", Some(DeclPrinter(t)), None)
+      SymbolInfo(t, "External type definition", Some(DeclPrinter(List(t))), None)
 
     case t: ExternInterface =>
-      SymbolInfo(t, "External interface definition", Some(DeclPrinter(t)), None)
+      SymbolInfo(t, "External interface definition", Some(DeclPrinter(List(t))), None)
 
     case t: ExternResource =>
-      SymbolInfo(t, "External resource definition", Some(DeclPrinter(t)), None)
+      SymbolInfo(t, "External resource definition", Some(DeclPrinter(List(t))), None)
 
     case c: Constructor =>
       val ex = pp"""|Instances of data types like `${c.tpe}` can only store
                     |_values_, not _blocks_. Hence, constructors like `${c.name}` only have
                     |value parameter lists, not block parameters.
                     |""".stripMargin
 
-      SymbolInfo(c, s"Constructor of data type `${c.tpe}`", Some(DeclPrinter(c)), Some(ex))
+      SymbolInfo(c, s"Constructor of data type `${c.tpe}`", Some(DeclPrinter(List(c))), Some(ex))
 
     case c: BlockParam =>
       val signature = C.functionTypeOption(c).map { tpe => pp"{ ${c.name}: ${tpe} }" }

effekt/shared/src/main/scala/effekt/Namer.scala

@@ -80,7 +80,7 @@ object Namer extends Phase[Parsed, NameResolved] {
    */
   def preresolve(d: Def)(using Context): Unit = Context.focusing(d) {
 
-    case d @ source.ValDef(id, annot, binding) =>
+    case d @ source.ValDef(binders, binding, _) =>
       ()
 
     case d @ source.VarDef(id, annot, region, binding) =>
@@ -225,10 +225,11 @@ object Namer extends Phase[Parsed, NameResolved] {
       Context.define(id, p)
       Context.bind(p.capture)
 
-    case d @ source.ValDef(id, annot, binding) =>
-      val tpe = annot.map(resolve)
+    case d @ source.ValDef(binders, binding, _) =>
       resolveGeneric(binding)
-      Context.define(id, ValBinder(Context.nameFor(id), tpe, d))
+      binders.foreach { case source.ValueParam(id, tpe) =>
+        Context.define(id, ValBinder(Name.local(id), tpe.map(resolve), d))
+      }
 
     case d @ source.VarDef(id, annot, region, binding) =>
       val tpe = annot.map(resolve)
@@ -377,8 +378,8 @@ object Namer extends Phase[Parsed, NameResolved] {
           }
       }
 
-    case source.MatchClause(pattern, body) =>
-      val ps = resolve(pattern)
+    case source.MatchClause(patterns, body) =>
+      val ps = patterns.flatMap(resolve)
 
       // wellformedness: only linear patterns
       var names: Set[Name] = Set.empty
@@ -552,7 +553,7 @@ object Namer extends Phase[Parsed, NameResolved] {
       case constructor: TypeConstructor => ValueTypeApp(constructor, args.map(resolve))
       case id: TypeVar =>
         if (args.nonEmpty) {
-          Context.abort(pretty"Type variables cannot be applied, but receieved ${args.size} arguments.")
+          Context.abort(pretty"Type variables cannot be applied, but received ${args.size} arguments.")
         }
         ValueTypeRef(id)
       case TypeAlias(name, tparams, tpe) =>
@@ -604,7 +605,7 @@ object Namer extends Phase[Parsed, NameResolved] {
 
       cps foreach Context.bind
 
-      val res = resolve(ret)
+      val res = ret map resolve
 
       FunctionType(tps, cps, vps, bps, res, effs)
     }
@@ -640,8 +641,8 @@ object Namer extends Phase[Parsed, NameResolved] {
   def resolve(tpe: source.Effects)(using Context): Effects =
     Effects(tpe.effs.flatMap(resolveWithAliases).toSeq: _*) // TODO this otherwise is calling the wrong apply
 
-  def resolve(e: source.Effectful)(using Context): (ValueType, Effects) =
-    (resolve(e.tpe), resolve(e.eff))
+  def resolve(e: source.Effectful)(using Context): (List[ValueType], Effects) =
+    (e.tpe map resolve, resolve(e.eff))
 
   def resolve(capt: source.CaptureSet)(using Context): CaptureSet = {
     val captResolved = CaptureSet(capt.captures.map { Context.resolveCapture }.toSet)