Don't cache given instances that are macros.

An inline given instance with a splice as right hand side should not be cached.

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import Flags._, Trees._, Types._, Contexts._
+import Flags._, Trees._, Types._, Contexts._, Constants.Constant
 import Names._, StdNames._, NameOps._, Symbols._
 import typer.ConstFold
 import reporting.trace
@@ -856,6 +856,16 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       case _ => None
     }
   }
+
+  object SplicedRHS {
+    /** Extracts splices, possibly wrapped in blocks or type ascriptions */
+    def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {
+      case Block(stat :: Nil, Literal(Constant(()))) => unapply(stat)
+      case Block(Nil, expr) => unapply(expr)
+      case Typed(expr, _) => unapply(expr)
+      case _ => Spliced.unapply(tree)
+    }
+  }
 }
 
 object TreeInfo {

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

@@ -31,29 +31,31 @@ trait MemoizeGivenAliases { this: Typer =>
    *
    *  It is then expanded as follows:
    *
-   *  1. If `rhs` is a simple name `x` (possibly with a `this.` prefix), leave the definition as is.
+   *  1. If `rhs` is a simple name `x` (possibly with a `this.` prefix),
+   *     or `rhs` is a splice, leave the definition as is.
    *  2. Otherwise, wrap `rhs` in a call to `scala.compiletime.memo`.
    */
   def memoizeGivenAlias(rhs: Tree, meth: Symbol) given Context : Tree = meth.info match {
     case ExprType(rhsType) if meth.is(Given, butNot = MemoizeGivenAliases.NoCacheFlags) =>
       // If rhs is a simple stable TermRef, leave as is.
-      val needsMemo = rhs.tpe match {
-        case rhsTpe @ TermRef(pre, _) if rhsTpe.isStable =>
-          pre match {
-            case NoPrefix => false
-            case pre: ThisType => pre.cls != meth.owner.enclosingClass
-            case _ => true
-          }
-        case _ => true
+      val needsMemo = rhs match {
+        case SplicedRHS(_) => false
+        case _ => rhs.tpe match {
+          case rhsTpe @ TermRef(pre, _) if rhsTpe.isStable =>
+            pre match {
+              case NoPrefix => false
+              case pre: ThisType => pre.cls != meth.owner.enclosingClass
+              case _ => true
+            }
+          case _ => true
+        }
       }
       if (needsMemo) {
         val memoized = ref(defn.Compiletime_memo).appliedToType(rhsType).appliedTo(rhs)
-        adapt(memoized, rhsType)
+        adapt(memoized, rhsType) // this will do the inlining of `memo`
       }
       else rhs
     case _ => rhs
   }
 }
 
-
-

docs/docs/reference/contextual/relationship-implicits.md

@@ -28,7 +28,7 @@ Given instances can be mapped to combinations of implicit objects, classes and i
       class ListOrd[T](implicit ord: Ord[T]) extends Ord[List[T]] { ... }
       final implicit def ListOrd[T](implicit ord: Ord[T]): ListOrd[T] = new ListOrd[T]
     ```
- 3. Alias givens map to implicit methods. If an alias has neither type parameters nor a given clause, its right-hand side is cached in a variable, unless the right hand side is a simple reference in which case we can use a forwarder to that reference without caching it.
+ 3. Alias givens map to implicit methods. If an alias is not a macro, and has neither type parameters nor a given clause, its right-hand side is cached in a variable, unless the right hand side is a simple reference in which case we can use a forwarder to that reference without caching it.
 
  Examples: