Fix #6909: Use memo to cache given aliases

Author: odersky

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -63,7 +63,6 @@ class Compiler {
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
          new ProtectedAccessors,     // Add accessors for protected members
          new ExtensionMethods,       // Expand methods of value classes with extension methods
-         new CacheAliasImplicits,    // Cache RHS of parameterless alias implicits
          new ShortcutImplicits,      // Allow implicit functions without creating closures
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope

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

@@ -887,7 +887,7 @@ object desugar {
   /** The normalized name of `mdef`. This means
    *   1. Check that the name does not redefine a Scala core class.
    *      If it does redefine, issue an error and return a mangled name instead of the original one.
-   *   2. If the name is missing (this can be the case for instance definitions), invent one instead.
+   *   2. If the name is missing (this can be the case for given instance definitions), invent one instead.
    */
   def normalizeName(mdef: MemberDef, impl: Tree)(implicit ctx: Context): Name = {
     var name = mdef.name
@@ -900,7 +900,7 @@ object desugar {
     name
   }
 
-  /** Invent a name for an anonymous instance with template `impl`.
+  /** Invent a name for an anonymous given instance with template `impl`.
    */
   private def inventName(impl: Tree)(implicit ctx: Context): String = impl match {
     case impl: Template =>
@@ -912,7 +912,7 @@ object desugar {
           case Some(DefDef(name, _, (vparam :: _) :: _, _, _)) =>
             s"${name}_of_${inventTypeName(vparam.tpt)}"
           case _ =>
-            ctx.error(i"anonymous instance must have `for` part or must define at least one extension method", impl.sourcePos)
+            ctx.error(i"anonymous given must have `as` part or must define at least one extension method", impl.sourcePos)
             nme.ERROR.toString
         }
       else

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

@@ -363,7 +363,6 @@ object NameKinds {
   val InlineAccessorName: PrefixNameKind = new PrefixNameKind(INLINEACCESSOR, "inline$")
 
   val AvoidClashName: SuffixNameKind = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$")
-  val CacheName = new SuffixNameKind(CACHE, "$_cache")
   val DirectMethodName: SuffixNameKind = new SuffixNameKind(DIRECT, "$direct") { override def definesNewName = true }
   val FieldName: SuffixNameKind = new SuffixNameKind(FIELD, "$$local") {
       override def mkString(underlying: TermName, info: ThisInfo) = underlying.toString

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

@@ -36,8 +36,6 @@ object NameTags extends TastyFormat.NameTags {
   final val IMPLMETH = 32       // Used to define methods in implementation classes
                                 // (can probably be removed).
 
-  final val CACHE = 33          // Used as a cache for the rhs of an alias implicit.
-
   def nameTagToString(tag: Int): String = tag match {
     case UTF8 => "UTF8"
     case QUALIFIED => "QUALIFIED"

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2334,7 +2334,7 @@ object Parsers {
        *    given C ...
        *  we know that `given` must start a parameter list. It cannot be a new given` definition.
        */
-      def followingIsInstanceDef =
+      def followingIsGivenDef =
         (ofClass || ofInstance) && {
           val lookahead = in.lookaheadScanner // skips newline on startup
           lookahead.nextToken()  // skip the `given`
@@ -2358,7 +2358,7 @@ object Parsers {
         var initialMods = EmptyModifiers
         val isNewLine = in.token == NEWLINE
         newLineOptWhenFollowedBy(LPAREN)
-        if (in.token == NEWLINE && in.next.token == GIVEN && !followingIsInstanceDef)
+        if (in.token == NEWLINE && in.next.token == GIVEN && !followingIsGivenDef)
           in.nextToken()
         if (in.token == GIVEN) {
           in.nextToken()
@@ -2761,7 +2761,7 @@ object Parsers {
         case ENUM =>
           enumDef(start, posMods(start, mods | Enum))
         case IMPLIED | GIVEN =>
-          instanceDef(in.token == GIVEN, start, mods, atSpan(in.skipToken()) { Mod.Given() })
+          givenDef(in.token == GIVEN, start, mods, atSpan(in.skipToken()) { Mod.Given() })
         case _ =>
           syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
           EmptyTree
@@ -2857,7 +2857,7 @@ object Parsers {
      *  GivenBody         ::=  [‘as ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
      *                      |  ‘as’ Type {GivenParamClause} ‘=’ Expr
      */
-    def instanceDef(newStyle: Boolean, start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
+    def givenDef(newStyle: Boolean, start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
       val name = if (isIdent && (!newStyle || in.name != nme.as)) ident() else EmptyTermName
       val tparams = typeParamClauseOpt(ParamOwner.Def)
@@ -3174,7 +3174,7 @@ object Parsers {
           val mods = modifiers(closureMods)
           mods.mods match {
             case givenMod :: Nil if !isBindingIntro =>
-              stats += instanceDef(true, start, EmptyModifiers, Mod.Given().withSpan(givenMod.span))
+              stats += givenDef(true, start, EmptyModifiers, Mod.Given().withSpan(givenMod.span))
             case _ =>
               stats += implicitClosure(in.offset, Location.InBlock, mods)
           }

compiler/src/dotty/tools/dotc/transform/CacheAliasImplicits.scala

@@ -0,0 +1,59 @@
+package dotty.tools.dotc
+package typer
+
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import ast.{untpd, tpd}
+
+object MemoizeGivenAliases {
+
+  /** Flags that disable caching */
+  val NoCacheFlags =
+    StableRealizable |  // It's a simple forwarder, leave it as one
+    Exported            // Export forwarders are never cached
+}
+
+trait MemoizeGivenAliases { this: Typer =>
+  import tpd._
+
+  /** Ensure that the right hand side of a parameterless given alias
+   *  is cached. This applies to all given aliases that have neither type parameters
+   *  nor a given clause. Example: The given alias
+   *
+   *      given a as TC = rhs
+   *
+   *  is desugared to
+   *
+   *      given def a: TC = rhs
+   *
+   *  It is then expanded as follows:
+   *
+   *  1. If `rhs` is a simple name `x` (possibly with a `this.` prefix), 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
+      }
+      if (needsMemo) {
+        val memoized =
+          untpd.Apply(untpd.ref(defn.Compiletime_memo.termRef), untpd.TypedSplice(rhs) :: Nil)
+        typed(memoized, rhsType)
+      }
+      else rhs
+    case _ => rhs
+  }
+}
+
+
+

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

@@ -88,6 +88,7 @@ class Typer extends Namer
                with Dynamic
                with Checking
                with QuotesAndSplices
+               with MemoizeGivenAliases
                with Deriving {
 
   import Typer._
@@ -1538,7 +1539,8 @@ class Typer extends Namer
     }
 
     if (sym.isInlineMethod) rhsCtx.addMode(Mode.InlineableBody)
-    val rhs1 = typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(rhsCtx)
+    val rhs0 = typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(rhsCtx)
+    val rhs1 = memoizeGivenAlias(rhs0, sym)
 
     if (sym.isInlineMethod) {
       PrepareInlineable.checkInlineMacro(sym, rhs1, ddef.sourcePos)