Name-based implicits in Effekt (#1380)

This implements implicits similar to
> Daan Leijen, Tim Whiting: Syntactic Implicit Parameters with Static
Overloading

It also implements their use to get source positions in the code.

### Syntax and Intended Behaviour
Putting a `?` in front of a value/block parameter makes it potentially
implicit. If *trailing* implicit parameters are missing, an argument is
generated as follows (e.g.):
- value argument called `$x`: `$x`
- value argument called `sourcePosition`:
`SourcePosition("somefilename.effekt",10,3,10,6)` (corresponding to the
source position of the called function, ~~without~~ with argument list)
- value argument called `callId`: A statically unique integer for *this*
call (unique within an Effekt compiler run).
- value argument of type `(...) => ... at {...}`: instantiated to `box
{...}` with whatever the block argument would be instantiated to.
- block argument called `$foo` of type `(A){B=>C} => D` : `{ (a: A){b: B
=> C} => $foo(a){b} }` (eta-expanded to allow for this call to also
receive implicit arguments)
- block argument with an interface type, called `$x`: `$x`

### Implementation strategy
- In `Namer`, 
- find the set of all implicit parameters that any of the overloads
could require (i.e. for all functions of that name, all implicit
parameters) and generate the source for them already.
- then name-resolve them, but collect errors and just store them (for
now)
- in `Typer`,
- instantiate the arguments (i.e., currently, hardcoded copy of the
block literal and corresponding annotations, or just copying them),
refreshing them and typechecking them against their respective
parameters
- only happens if at this point, no errors were reported in this case
(otherwise, aborts)
    - annotate the instantiated arguments
- in `ExplicitCapabilities`, actually change the source to pass the
annotated arguments explicitly.

### TODO and limitations
- [x] ~~Check if this works for more than the existing examples (find at
least the worst bugs)~~ The tests should be testing a good part of
possible uses now.
- [x] This *will* cause *Typer* to run indefinitely or stack-overflow if
the search is not terminated by a type/name error. We could try to catch
those cases somehow, but this is nontrivial (and will reject valid
programs).
    - Opinions?
- The recursion is ~~quite indirect (and not actual recursion) in typer,
and~~ (we can check for recursive uses when checking implicit arguments
after instantiating them - this is separate now anyway) at a point where
we don't necessarily have the concrete types (due to unification), so
checking for "decreasing type size" or similar is potentially hard.
- Now aborts if, at the same name, we have 10 levels where the expected
type does not get smaller.
- [x] Syntax bikeshedding
- [ ] If merging this, we might want to change #1381 / #1123 s.t. they
provide only the definitions for base and recursive cases (not for all
types used etc).

---------

Co-authored-by: Jonathan Immanuel Brachthäuser <jonathan.brachthaeuser@uni-tuebingen.de>

Author: marzipankaiser

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

@@ -130,6 +130,7 @@ enum TokenKind {
   case `...`
   case `^^`
   case `^`
+  case `?`
 
   // keywords
   case `let`
@@ -472,6 +473,7 @@ class Lexer(source: Source) extends Iterator[Token] {
 
       case ('*', '=') => advanceWith(TokenKind.`*=`)
       case ('*', _)   => advanceWith(TokenKind.`*`)
+      case ('?', _)   => advanceWith(TokenKind.`?`)
 
       case ('$', '{') =>
         interpolationDepths.push(depthTracker.braces + 1)

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

@@ -7,14 +7,16 @@ package namer
 import effekt.context.{Annotations, Context, ContextOps}
 import effekt.context.assertions.*
 import effekt.typer.Substitutions
-import effekt.source.{Def, Id, IdDef, IdRef, Many, MatchGuard, ModuleDecl, Term, Tree, sourceOf}
+import effekt.source.{Def, Id, IdDef, IdRef, Many, MatchGuard, ModuleDecl, Term, Tree, sourceOf, GenerateImplicitArgs}
 import effekt.symbols.*
 import effekt.util.messages.ErrorMessageReifier
 import effekt.symbols.scopes.*
+import effekt.context.Try
 
 import scala.annotation.tailrec
 import scala.collection.mutable
 import scala.util.DynamicVariable
+import effekt.util.RequirementLevel
 
 /**
  * The output of this phase: a mapping from source identifier to symbol
@@ -337,6 +339,7 @@ object Namer extends Phase[Parsed, NameResolved] {
 
     // FunDef and InterfaceDef have already been resolved as part of the module declaration
     case f @ source.FunDef(id, tparams, vparams, bparams, captures, ret, body, doc, span) =>
+      checkImplicitParams(vparams.unspan); checkImplicitParams(bparams.unspan)
       val sym = f.symbol
       Context.scopedWithName(id.name) {
         sym.tparams.foreach { p => Context.bind(p) }
@@ -347,6 +350,7 @@ object Namer extends Phase[Parsed, NameResolved] {
       }
 
     case f @ source.ExternDef(id, tparams, vparams, bparams, captures, ret, bodies, doc, span) =>
+      checkImplicitParams(vparams.unspan); checkImplicitParams(bparams.unspan)
       val sym = f.symbol
       Context.scopedWithName(id.name) {
         sym.tparams.foreach { p => Context.bind(p) }
@@ -364,6 +368,7 @@ object Namer extends Phase[Parsed, NameResolved] {
       val interface = Context.symbolOf(interfaceId).asInterface
       interface.operations = operations.map {
         case op @ source.Operation(id, tparams, vparams, bparams, ret, doc, span) => Context.at(op) {
+          checkImplicitParams(vparams); checkImplicitParams(bparams)
           val name = Context.nameFor(id)
 
           val opSym = Context.scopedWithName(id.name) {
@@ -445,6 +450,47 @@ object Namer extends Phase[Parsed, NameResolved] {
     resolve(a.value)
   }
 
+  /**
+   * Checks that there are no implicit parameters if there shouldn't be (or there are if there must be).
+   * Also checks that there are no non-implicit parameters after implicit ones.
+   */
+  @tailrec
+  def checkImplicitParams(l: List[source.Param], implicitsAllowed: RequirementLevel = RequirementLevel.Optional)(using Context): Unit = (l, implicitsAllowed) match {
+    case ((p@(source.ValueParam(_, _, true, _) | source.BlockParam(_, _, true, _))) :: tl, RequirementLevel.Forbidden) =>
+      Context.at(p) {
+        Context.error(pretty"Implicit parameter ${l.head.span.text.getOrElse(l.head.id.name)} can never be passed implicitly to here.")
+      }
+    case ((p@(source.ValueParam(_, _, false, _) | source.BlockParam(_, _, false, _))) :: tl, RequirementLevel.Required) =>
+      Context.at(p) {
+        Context.error(pretty"Parameter ${l.head.span.text.getOrElse(l.head.id.name)} needs to be implicit so earlier implicit parameters can be passed implicitly.")
+      }
+    case ((source.ValueParam(_, _, true, _) | source.BlockParam(_, _, true, _)) :: tl, RequirementLevel.Optional) =>
+      checkImplicitParams(tl, RequirementLevel.Required) // require all arguments after an implicit one to be implicit
+    case (_ :: tl, _) =>
+      checkImplicitParams(tl, implicitsAllowed)
+    case (Nil, _) => ()
+  }
+
+  /**
+   * Name-resolves all implicit arguments that could be interesting for calling the given function symbol.
+   *
+   * Errors while doing so are residualized into the respective [[ImplicitContext]] and only reported
+   * during overload resolution later.
+   */
+  def resolveImplicits(id: source.Id)(using Context): Unit = {
+    Context.symbolOf(id) match {
+      case symbols.CallTarget(syms, cs) =>
+        cs.foreach {
+          case (b, c@ImplicitContext(vimpls, bimpls)) if !c.resolved =>
+            c.resolved = true // set as resolved first, so recursive calls do not continue doing so.
+            c.values = vimpls.map { case k -> mv => k -> GenerateImplicitArgs.runPhaseOn(k, mv){ v => Try { resolve(v) } } }
+            c.blocks = bimpls.map { case k -> mb => k -> GenerateImplicitArgs.runPhaseOn(k, mb){ b => Try { resolve(b) } } }
+          case _ => ()
+        }
+      case _ => ()
+    }
+  }
+
   def resolve(t: source.Term)(using Context): Unit = Context.focusing(t) {
 
     case source.Literal(value, tpe, _) => ()
@@ -491,14 +537,16 @@ object Namer extends Phase[Parsed, NameResolved] {
 
     case tree @ source.Region(name, body, _) =>
       val regionName = Name.local(name.name)
-      val reg = BlockParam(regionName, Some(builtins.TRegion), CaptureParam(regionName), tree)
+      val reg = BlockParam(regionName, Some(builtins.TRegion), CaptureParam(regionName), isImplicit = false, tree)
       Context.define(name, reg)
       Context scoped {
         Context.bindBlock(reg)
         resolve(body)
       }
 
     case f @ source.BlockLiteral(tparams, vparams, bparams, stmt, _) =>
+      checkImplicitParams(vparams, RequirementLevel.Forbidden)
+      checkImplicitParams(bparams, RequirementLevel.Forbidden)
       Context scoped {
         val tps = tparams map resolve
         val vps = vparams map resolve
@@ -551,19 +599,21 @@ object Namer extends Phase[Parsed, NameResolved] {
             then Context.abort(pp"Cannot resolve function ${target}, called on an expression.")
         }
       }
+      resolveImplicits(target)
       targs foreach resolveValueType
       vargs foreach resolve
       bargs foreach resolve
 
     case source.Do(target, targs, vargs, bargs, _) =>
       Context.resolveEffectCall(target)
+      resolveImplicits(target)
       targs foreach resolveValueType
       vargs foreach resolve
       bargs foreach resolve
 
     case source.Call(target, targs, vargs, bargs, _) =>
       Context.focusing(target) {
-        case source.IdTarget(id)     => Context.resolveFunctionCalltarget(id)
+        case source.IdTarget(id)     => Context.resolveFunctionCalltarget(id); resolveImplicits(id)
         case source.ExprTarget(expr) => resolve(expr)
       }
       targs foreach resolveValueType
@@ -666,19 +716,19 @@ object Namer extends Phase[Parsed, NameResolved] {
    * Used for fields where "please wrap this in braces" is not good advice to be told by [[resolveValueType]].
    */
   def resolveNonfunctionValueParam(p: source.ValueParam)(using Context): ValueParam = {
-    val sym = ValueParam(Name.local(p.id), p.tpe.map(tpe => resolveValueType(tpe, isParam = false)), decl = p)
+    val sym = ValueParam(Name.local(p.id), p.tpe.map(tpe => resolveValueType(tpe, isParam = false)), p.isImplicit, decl = p)
     Context.assignSymbol(p.id, sym)
     sym
   }
 
   def resolve(p: source.ValueParam)(using Context): ValueParam = {
-    val sym = ValueParam(Name.local(p.id), p.tpe.map(tpe => resolveValueType(tpe, isParam = true)), decl = p)
+    val sym = ValueParam(Name.local(p.id), p.tpe.map(tpe => resolveValueType(tpe, isParam = true)), p.isImplicit, decl = p)
     Context.assignSymbol(p.id, sym)
     sym
   }
   def resolve(p: source.BlockParam)(using Context): BlockParam = {
     val name = Name.local(p.id)
-    val sym: BlockParam = BlockParam(name, p.tpe.map { tpe => resolveBlockType(tpe, isParam = true) }, CaptureParam(name), p)
+    val sym: BlockParam = BlockParam(name, p.tpe.map { tpe => resolveBlockType(tpe, isParam = true) }, CaptureParam(name), p.isImplicit, p)
     Context.assignSymbol(p.id, sym)
     sym
   }
@@ -719,7 +769,7 @@ object Namer extends Phase[Parsed, NameResolved] {
     case source.IgnorePattern(_)     => Nil
     case source.LiteralPattern(lit, _) => Nil
     case source.AnyPattern(id, _) =>
-      val p = ValueParam(Name.local(id), None, decl = id)
+      val p = ValueParam(Name.local(id), None, isImplicit = false, decl = id)
       Context.assignSymbol(id, p)
       List(p)
     case source.TagPattern(id, patterns, _) =>
@@ -1081,7 +1131,11 @@ trait NamerOps extends ContextOps { Context: Context =>
 
     val syms2 = if (syms.isEmpty) scope.lookupFunction(id.path, id.name) else syms
 
-    if (syms2.nonEmpty) { assignSymbol(id, CallTarget(syms2.asInstanceOf)); true } else { false }
+    if (syms2.nonEmpty) {
+      val syms3 = syms2.asInstanceOf[List[Set[BlockSymbol]]]
+      assignSymbol(id, CallTarget(syms3, GenerateImplicitArgs.lookupPotentialImplicits(syms3, scope.scope)))
+      true
+    } else { false }
   }
 
   private[namer] def resolveOverloadedFunction(id: IdRef): Boolean = at(id) {
@@ -1092,7 +1146,11 @@ trait NamerOps extends ContextOps { Context: Context =>
     // lookup first block param and do not collect multiple since we do not (yet?) permit overloading on block parameters
     val syms3 = if (syms2.isEmpty) List(scope.lookupFirstBlockParam(id.path, id.name)) else syms2
 
-    if (syms3.nonEmpty) { assignSymbol(id, CallTarget(syms3.asInstanceOf)); true } else { false }
+    if (syms3.nonEmpty) {
+      val syms4 = syms3.asInstanceOf[List[Set[BlockSymbol]]]
+      assignSymbol(id, CallTarget(syms4, GenerateImplicitArgs.lookupPotentialImplicits(syms4, scope.scope)))
+      true
+    } else { false }
   }
 
   /**
@@ -1116,7 +1174,7 @@ trait NamerOps extends ContextOps { Context: Context =>
           // Always abort with the generic message
           abort(pretty"Cannot find a function named `${id}`.")
         }
-        assignSymbol(id, CallTarget(blocks))
+        assignSymbol(id, CallTarget(blocks, GenerateImplicitArgs.lookupPotentialImplicits(blocks, scope.scope)))
     }
   }
 
@@ -1170,7 +1228,8 @@ trait NamerOps extends ContextOps { Context: Context =>
       abort(pretty"Cannot resolve field access ${id}")
     }
 
-    assignSymbol(id, CallTarget(syms.asInstanceOf))
+    val bsyms = syms.asInstanceOf[List[Set[BlockSymbol]]]
+    assignSymbol(id, CallTarget(bsyms, GenerateImplicitArgs.lookupPotentialImplicits(bsyms, scope.scope)))
   }
 
   /**
@@ -1184,7 +1243,8 @@ trait NamerOps extends ContextOps { Context: Context =>
       abort(pretty"Cannot resolve effect operation ${id}")
     }
 
-    assignSymbol(id, CallTarget(syms.asInstanceOf))
+    val bsyms = syms.asInstanceOf[List[Set[BlockSymbol]]]
+    assignSymbol(id, CallTarget(bsyms, GenerateImplicitArgs.lookupPotentialImplicits(bsyms, scope.scope)))
   }
 
   /**

effekt/shared/src/main/scala/effekt/Parser.scala

@@ -195,6 +195,9 @@ class Parser(tokens: Seq[Token], source: Source) {
   def peek(offset: Int, kind: TokenKind): Boolean =
     peek(offset).kind == kind
 
+  def skipIf(kind: TokenKind): Boolean =
+    if (peek.kind == kind) { skip(); true } else { false }
+
   def hasNext(): Boolean = position < tokens.length
   def next(): Token =
     val t = tokens(position).failOnErrorToken(position)
@@ -331,8 +334,8 @@ class Parser(tokens: Seq[Token], source: Source) {
       // Simple case: all patterns are just variable names (or ignored), no guards, no fallback
       // Desugar to: call { (x, y, _, ...) => body }
       val vparams: List[ValueParam] = patterns.unspan.map {
-        case AnyPattern(id, span) => ValueParam(id, None, span)
-        case IgnorePattern(span) => ValueParam(IdDef(s"__ignored", span.synthesized), None, span)
+        case AnyPattern(id, span) => ValueParam(id, None, isImplicit = false, span)
+        case IgnorePattern(span) => ValueParam(IdDef(s"__ignored", span.synthesized), None, isImplicit = false, span)
         case _ => sys.error("impossible: checked above")
       }
       BlockLiteral(Nil, vparams, Nil, body, body.span.synthesized)
@@ -345,7 +348,7 @@ class Parser(tokens: Seq[Token], source: Source) {
       val argSpans = patternList.map(_.span)
 
       val vparams: List[ValueParam] = names.zip(argSpans).map { (name, span) =>
-        ValueParam(IdDef(name, span.synthesized), None, span.synthesized)
+        ValueParam(IdDef(name, span.synthesized), None, isImplicit = false, span.synthesized)
       }
       val scrutinees = names.zip(argSpans).map { (name, span) =>
         Var(IdRef(Nil, name, span.synthesized), span.synthesized)
@@ -931,7 +934,7 @@ class Parser(tokens: Seq[Token], source: Source) {
     nonterminal:
       `with` ~> backtrack(idDef() <~ `:`) ~ implementation() match {
         case capabilityName ~ impl =>
-          val capability = capabilityName map { name => BlockParam(name, Some(impl.interface), name.span.synthesized): BlockParam }
+          val capability = capabilityName map { name => BlockParam(name, Some(impl.interface), isImplicit = false, name.span.synthesized): BlockParam }
           Handler(capability.unspan, impl, span())
       }
 
@@ -1284,7 +1287,7 @@ class Parser(tokens: Seq[Token], source: Source) {
               val names = List.tabulate(argSpans.length){ n => s"__arg${n}" }
               BlockLiteral(
                 Nil,
-                names.zip(argSpans).map { (name, span) => ValueParam(IdDef(name, span.synthesized), None, span.synthesized) },
+                names.zip(argSpans).map { (name, span) => ValueParam(IdDef(name, span.synthesized), None, isImplicit = false, span.synthesized) },
                 Nil,
                 Return(
                   Match(
@@ -1654,7 +1657,7 @@ class Parser(tokens: Seq[Token], source: Source) {
 
   def lambdaParams(): (List[Id], List[ValueParam], List[BlockParam]) =
     nonterminal:
-      if isVariable then (Nil, List(ValueParam(idDef(), None, span())), Nil)  else paramsOpt()
+      if isVariable then (Nil, List(ValueParam(idDef(), None, isImplicit=false, span())), Nil)  else paramsOpt()
 
   def params(): (Many[Id], Many[ValueParam], Many[BlockParam]) =
     nonterminal:
@@ -1688,11 +1691,13 @@ class Parser(tokens: Seq[Token], source: Source) {
 
   def valueParam(): ValueParam =
     nonterminal:
-      ValueParam(idDef(), Some(valueTypeAnnotation()), span())
+      val isImplicit = skipIf(`?`)
+      ValueParam(idDef(), Some(valueTypeAnnotation()), isImplicit, span())
 
   def valueParamOpt(): ValueParam =
     nonterminal:
-      ValueParam(idDef(), maybeValueTypeAnnotation(), span())
+      val isImplicit = skipIf(`?`)
+      ValueParam(idDef(), maybeValueTypeAnnotation(), isImplicit, span())
 
   def maybeBlockParams(): Many[BlockParam] =
     nonterminal:
@@ -1712,11 +1717,13 @@ class Parser(tokens: Seq[Token], source: Source) {
 
   def blockParam(): BlockParam =
     nonterminal:
-      BlockParam(idDef(), Some(blockTypeAnnotation()), span())
+      val isImplicit = skipIf(`?`)
+      BlockParam(idDef(), Some(blockTypeAnnotation()), isImplicit, span())
 
   def blockParamOpt(): BlockParam =
     nonterminal:
-      BlockParam(idDef(), when(`:`)(Some(blockType()))(None), span())
+      val isImplicit = skipIf(`?`)
+      BlockParam(idDef(), when(`:`)(Some(blockType()))(None), isImplicit, span())
 
   def maybeValueTypes(): Many[Type] =
     nonterminal: