Implement summonFrom as a replacement for implicit match

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -220,6 +220,7 @@ class Definitions {
     @tu lazy val Compiletime_constValue   : Symbol = CompiletimePackageObject.requiredMethod("constValue")
     @tu lazy val Compiletime_constValueOpt: Symbol = CompiletimePackageObject.requiredMethod("constValueOpt")
     @tu lazy val Compiletime_code         : Symbol = CompiletimePackageObject.requiredMethod("code")
+    @tu lazy val Compiletime_summonFrom   : Symbol = CompiletimePackageObject.requiredMethod("summonFrom")
   @tu lazy val CompiletimeTestingPackageObject: Symbol = ctx.requiredModule("scala.compiletime.testing.package")
     @tu lazy val CompiletimeTesting_typeChecks   : Symbol = CompiletimeTestingPackageObject.requiredMethod("typeChecks")
 

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -890,7 +890,14 @@ trait Applications extends Compatibility {
         case err: ErrorType => cpy.Apply(tree)(fun1, proto.unforcedTypedArgs).withType(err)
         case TryDynamicCallType => typedDynamicApply(tree, pt)
         case _ =>
-          if (originalProto.isDropped) fun1
+          if originalProto.isDropped then fun1
+          else if fun1.symbol == defn.Compiletime_summonFrom then
+            tree.args match {
+              case (arg @ Match(EmptyTree, cases)) :: Nil =>
+                typed(untpd.InlineMatch(EmptyTree, cases).withSpan(arg.span), pt)
+              case _ =>
+                errorTree(tree, em"argument to summonFrom must be a pattern matching closure")
+            }
           else
             tryEither {
               simpleApply(fun1, proto)

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -796,9 +796,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     /** Reduce an inline match
      *   @param     mtch          the match tree
      *   @param     scrutinee     the scrutinee expression, assumed to be pure, or
-     *                            EmptyTree for a delegate match
+     *                            EmptyTree for a summonFrom
      *   @param     scrutType     its fully defined type, or
-     *                            ImplicitScrutineeTypeRef for a delegate match
+     *                            ImplicitScrutineeTypeRef for a summonFrom
      *   @param     typer         The current inline typer
      *   @return    optionally, if match can be reduced to a matching case: A pair of
      *              bindings for all pattern-bound variables and the RHS of the case.
@@ -1072,11 +1072,10 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
     override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree =
       constToLiteral(betaReduce(super.typedApply(tree, pt))) match {
-        case res: Apply
-        if res.symbol == defn.InternalQuoted_exprSplice &&
-           level == 0 &&
-           call.symbol.is(Macro) &&
-           !suppressInline =>
+        case res: Apply if res.symbol == defn.InternalQuoted_exprSplice
+                        && level == 0
+                        && call.symbol.is(Macro)
+                        && !suppressInline =>
           expandMacro(res.args.head, tree.span)
         case res => res
       }
@@ -1115,7 +1114,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
             def patStr(cdef: untpd.CaseDef) = i"case ${cdef.pat}${guardStr(cdef.guard)}"
             val msg =
               if (tree.selector.isEmpty)
-                em"""cannot reduce delegate match with
+                em"""cannot reduce summonFrom with
                    | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
               else
                 em"""cannot reduce inline match with

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1090,7 +1090,7 @@ class Typer extends Namer
     tree.selector match {
       case EmptyTree =>
         if (tree.isInline) {
-          checkInInlineContext("delegate match", tree.posd)
+          checkInInlineContext("summonFrom", tree.posd)
           val cases1 = tree.cases.mapconserve {
             case cdef @ CaseDef(pat @ Typed(Ident(nme.WILDCARD), _), _, _) =>
               // case _ : T  -->  case evidence$n : T

library/src/scala/compiletime/package.scala

@@ -37,5 +37,20 @@ package object compiletime {
 
   inline def constValue[T]: T = ???
 
+  /** Summons first given matching one of the listed cases. E.g. in
+   *
+   *      given B { ... }
+   *
+   *      summonFrom {
+   *        case given A => 1
+   *        case given B => 2
+   *        case given C => 3
+   *        case _ => 4
+   *      }
+   *
+   *  the returned value would be `2`.
+   */
+  inline def summonFrom(f: Nothing => Any) <: Any = ???
+
   type S[X <: Int] <: Int
 }

library/src/scala/tasty/reflect/Core.scala

@@ -216,7 +216,7 @@ trait Core {
         /** Tree representing a pattern match `x match  { ... }` in the source code */
         type Match = internal.Match
 
-        /** Tree representing a pattern match `delegate match { ... }` in the source code */
+        /** Tree representing a pattern match `delegate match { ... }` in the source code */  // TODO: drop
         type ImpliedMatch = internal.ImpliedMatch
 
         /** Tree representing a try catch `try x catch { ... } finally { ... }` in the source code */

tests/neg/cannot-reduce-delegate-match.scala renamed to tests/neg/cannot-reduce-summonFrom.scala

@@ -1,7 +1,7 @@
 object Test {
 
   inline def bar() =
-    delegate match { // error
+    compiletime.summonFrom {  // error
       case _: Int =>
     }
 

tests/neg/implicitMatch-syntax.scala

@@ -2,7 +2,7 @@ object `implicit-match-ambiguous-bind` {
   case class Box[T](value: T)
   implicit val ibox: Box[Int] = Box(0)
   implicit val sbox: Box[String] = Box("")
-  inline def unbox = delegate match {
+  inline def unbox = compiletime.summonFrom {
     case b: Box[t] => b.value // error
   }
   val unboxed = unbox

tests/neg/implicit-match-ambiguous-bind.scala renamed to tests/neg/summonFrom-ambiguous-bind.scala

@@ -4,7 +4,7 @@ object Test {
   implicit val a1: A = new A
   implicit val a2: A = new A
 
-  inline def f: Any = delegate match {
+  inline def f: Any = compiletime.summonFrom {
     case _: A => ???  // error: ambiguous implicits
   }