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
   }
 

tests/invalid/neg/implicitMatch-ambiguous.scala renamed to tests/neg/summonFrom-ambiguous.scala

@@ -210,10 +210,10 @@ trait Show[T] {
   def show(x: T): String
 }
 object Show {
-  import scala.compiletime.{erasedValue, error}
+  import scala.compiletime.{erasedValue, error, summonFrom}
   import TypeLevel._
 
-  inline def tryShow[T](x: T): String = delegate match {
+  inline def tryShow[T](x: T): String = summonFrom {
     case s: Show[T] => s.show(x)
   }
 

tests/neg/typeclass-derivation2.scala

@@ -1,9 +1,10 @@
-// delegate matches that bind parameters don't work yet.
-object `implicit-match` {
+// summonFroms that bind parameters don't work yet.
+import compiletime.summonFrom
+object summonFroms {
   object invariant {
     case class Box[T](value: T)
     implicit val box: Box[Int] = Box(0)
-    inline def unbox <: Any = delegate match {
+    inline def unbox <: Any = summonFrom {
       case b: Box[t] => b.value
     }
     val i: Int = unbox
@@ -14,7 +15,7 @@ object `implicit-match` {
   object covariant {
     case class Box[+T](value: T)
     implicit val box: Box[Int] = Box(0)
-    inline def unbox <: Any = delegate match {
+    inline def unbox <: Any = summonFrom {
       case b: Box[t] => b.value
     }
     val i: Int = unbox
@@ -25,7 +26,7 @@ object `implicit-match` {
   object contravariant {
     case class TrashCan[-T](trash: T => Unit)
     implicit val trashCan: TrashCan[Int] = TrashCan { i => ; }
-    inline def trash <: Nothing => Unit = delegate match {
+    inline def trash <: Nothing => Unit = summonFrom {
       case c: TrashCan[t] => c.trash
     }
     val t1: Int => Unit = trash

tests/pending/pos/implicit-match.scala renamed to tests/pending/pos/summonFrom.scala

@@ -207,6 +207,7 @@ object datatypes {
 }
 
 object typeclasses {
+  import compiletime.summonFrom
   // A typeclass
   trait Eq[T] {
     def eql(x: T, y: T): Boolean
@@ -217,7 +218,7 @@ object typeclasses {
     import compiletime._
     import scala.deriving._
 
-    inline def tryEql[TT](x: TT, y: TT): Boolean = delegate match {
+    inline def tryEql[TT](x: TT, y: TT): Boolean = summonFrom {
       case eq: Eq[TT] => eq.eql(x, y)
     }
 
@@ -237,7 +238,7 @@ object typeclasses {
       inline erasedValue[Alts] match {
         case _: (alt *: alts1) =>
           if (ord == n)
-            delegate match {
+            summonFrom {
               case m: Mirror.ProductOf[`alt`] => eqlElems[m.MirroredElemTypes](0)(x, y)
             }
           else eqlCases[alts1](n + 1)(x, y, ord)
@@ -274,7 +275,7 @@ object typeclasses {
 
     def nextInt(buf: mutable.ListBuffer[Int]): Int = try buf.head finally buf.trimStart(1)
 
-    inline def tryPickle[T](buf: mutable.ListBuffer[Int], x: T): Unit = delegate match {
+    inline def tryPickle[T](buf: mutable.ListBuffer[Int], x: T): Unit = summonFrom {
       case pkl: Pickler[T] => pkl.pickle(buf, x)
     }
 
@@ -290,14 +291,14 @@ object typeclasses {
       inline erasedValue[Alts] match {
         case _: (alt *: alts1) =>
           if (ord == n)
-            delegate match {
+            summonFrom {
               case m: Mirror.ProductOf[`alt`] => pickleElems[m.MirroredElemTypes](0)(buf, x)
             }
           else pickleCases[alts1](n + 1)(buf, x, ord)
         case _: Unit =>
       }
 
-    inline def tryUnpickle[T](buf: mutable.ListBuffer[Int]): T = delegate match {
+    inline def tryUnpickle[T](buf: mutable.ListBuffer[Int]): T = summonFrom {
       case pkl: Pickler[T] => pkl.unpickle(buf)
     }
 
@@ -324,7 +325,7 @@ object typeclasses {
       inline erasedValue[Alts] match {
         case _: (alt *: alts1) =>
           if (ord == n)
-            delegate match {
+            summonFrom {
               case m: Mirror.ProductOf[`alt` & T] =>
                 unpickleCase[`alt` & T, m.MirroredElemTypes](buf, m)
             }

tests/pos-special/typeclass-scaling.scala

@@ -1,11 +1,14 @@
+import compiletime.summonFrom
+
 trait Link[T, A]
 
-inline def link[T] = delegate match {
-  case _: Link[T, s] =>
-    delegate match {
-      case stuff: s => stuff
-    }
-}
+inline def link[T] =
+  summonFrom {
+    case _: Link[T, s] =>
+      summonFrom {
+        case stuff: s => stuff
+      }
+  }
 
 class Foo
 object Foo {

tests/pos/i5938.scala

@@ -10,7 +10,7 @@ object Test1 {
 }
 
 object Test2 {
-  inline def summon[T] = delegate match {
+  inline def summon[T] = summonFrom {
     case t: T => t
   }
 
@@ -25,7 +25,7 @@ object Test2 {
 }
 
 object Test3 {
-  inline def summon[T] = delegate match {
+  inline def summon[T] = summonFrom {
     case t: T => t
   }
 
@@ -42,7 +42,7 @@ object Test3 {
 }
 
 object Test4 {
-  inline def summon[T] = delegate match {
+  inline def summon[T] = summonFrom {
     case t: T => t
   }
 

tests/pos/i6014-gadt.scala

@@ -5,7 +5,7 @@ object `implicit-match-and-inline-match` {
   implicit val ibox: Box[Int] = Box(0)
 
   object a {
-    inline def isTheBoxInScopeAnInt = delegate match {
+    inline def isTheBoxInScopeAnInt = summonFrom {
       case _: Box[t] => inline erasedValue[t] match {
         case _: Int => true
       }
@@ -14,7 +14,7 @@ object `implicit-match-and-inline-match` {
   }
 
   object b {
-    inline def isTheBoxInScopeAnInt = delegate match {
+    inline def isTheBoxInScopeAnInt = summonFrom {
       case _: Box[t] => inline 0 match {
         case _: t => true
       }

tests/pos/implicit-match-and-inline-match.scala

@@ -1,16 +1,20 @@
 object `implicit-match-nested` {
+  import compiletime.summonFrom
+
   case class A[T]()
   case class B[T]()
 
   implicit val a: A[Int] = A[Int]()
   implicit val b1: B[Int] = B[Int]()
   implicit val b2: B[String] = B[String]()
 
-  inline def locateB <: B[_] = delegate match {
-    case _: A[t] => delegate match {
-      case b: B[`t`] => b
+  inline def locateB <: B[_] =
+    summonFrom {
+      case _: A[t] =>
+        summonFrom {
+          case b: B[`t`] => b
+        }
     }
-  }
 
   locateB
 }

tests/pos/implicit-match-nested.scala

@@ -1,5 +1,5 @@
 object A {
-  inline def summon[T] = delegate match {
+  inline def summon[T] = compiletime.summonFrom {
     case t: T => t
   }
 }