Cache right hand side of parameterless alias implicits

Author: odersky

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

@@ -62,6 +62,7 @@ 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/core/NameKinds.scala

@@ -359,6 +359,7 @@ 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,6 +36,8 @@ 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/transform/CacheAliasImplicits.scala

@@ -0,0 +1,104 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers.{IdentityDenotTransformer}
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import core.StdNames.nme
+import core.NameKinds.CacheName
+import core.Constants.Constant
+import core.Decorators._
+import core.TypeErasure.erasure
+import ast.tpd
+
+object CacheAliasImplicits {
+  val name: String = "cacheAliasImplicits"
+
+  /** Flags that disable caching */
+  val NoCacheFlags =
+    StableRealizable |  // It's a simple forwarder, leave it as one
+    Exported            // Export forwarders are never cached
+}
+
+/** This phase ensures that the right hand side of parameterless alias implicits
+ *  is cached. It applies to all alias implicits that have neither type parameters
+ *  not a given clause. Example: The alias
+ *
+ *      implicit a for TC = rhs
+ *
+ *  is expanded before this phase
+ *
+ *      implicit def a: TC = rhs
+ *
+ *  It is then expanded further as follows:
+ *
+ *  1. If `rhs` is a simple name `x` (possibly with a `this.` prefix), leave the definition as is.
+ *  2. Otherwise, if `rhs` is a pure path, replace the definition with
+ *
+ *      implicit val a: TC = rhs
+ *
+ *  3. Otherwise, if `TC` is a reference type, replace the definition with
+ *
+ *      private[this] var a$_cache: TC = null
+ *      implicit def a: TC = { if (a$_cache == null) a$_cache = rhs; a$_cache }
+ *
+ *  4. Otherwise `TC` is a value type. Replace the definition with
+ *
+ *      lazy implicit val a: TC = rhs
+ */
+class CacheAliasImplicits extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import tpd._
+
+  override def phaseName: String = CacheAliasImplicits.name
+
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
+    val sym = tree.symbol
+    sym.info match {
+      case ExprType(rhsType) if sym.is(Implied, butNot = CacheAliasImplicits.NoCacheFlags) =>
+        // If rhs is a simple TermRef, leave a def.
+        tree.rhs.tpe match {
+          case TermRef(pre, _) =>
+            pre match {
+              case NoPrefix => return tree
+              case pre: ThisType if pre.cls == ctx.owner.enclosingClass => return tree
+              case _ =>
+            }
+          case _ =>
+        }
+        def makeVal(additionalFlags: FlagSet) = {
+          sym.copySymDenotation(
+              initFlags = sym.flags &~ Method | additionalFlags,
+              info = rhsType)
+            .installAfter(thisPhase)
+          cpy.ValDef(tree)(tree.name, tree.tpt, tree.rhs)
+        }
+        if (isPurePath(tree.rhs)) makeVal(EmptyFlags)
+        else if (rhsType.classSymbol.isValueClass ||
+                 !erasure(rhsType).typeSymbol.derivesFrom(defn.ObjectClass)) makeVal(Lazy)
+        else {
+          val cacheFlags = if (ctx.owner.isClass) Private | Local | Mutable else Mutable
+          val cacheSym =
+            ctx.newSymbol(ctx.owner, CacheName(tree.name), cacheFlags, rhsType, coord = sym.coord)
+          if (ctx.owner.isClass) cacheSym.enteredAfter(thisPhase)
+          val cacheDef = ValDef(cacheSym, tpd.defaultValue(rhsType))
+          val cachingDef = cpy.DefDef(tree)(rhs =
+            Block(
+              If(
+                ref(cacheSym).select(defn.Any_==).appliedTo(nullLiteral),
+                Assign(ref(cacheSym), tree.rhs),
+                unitLiteral) :: Nil,
+              ref(cacheSym)
+            )
+          )
+          Thicket(cacheDef, cachingDef)
+        }
+      case _ => tree
+    }
+  }
+}
+
+
+

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

@@ -32,7 +32,7 @@ Implicit instances can be mapped to combinations of implicit objects and implici
 
   - If the right hand side is a simple reference, we can
     use a forwarder to that reference without caching it.
-  - If the right hand side is more complex, but still known to be pure, we can
+  - If the right hand side is more complex, but still known to be a pure path, we can
     create a `val` that computes it ahead of time.
 
  Examples:

tests/run/implicit-alias.check

@@ -0,0 +1,14 @@
+= new
+TC
+= x
+TC
+= new VC
+TC
+TC
+= x.y
+with given
+TC
+TC
+with type params
+TC
+TC

tests/run/implicit-alias.scala

@@ -0,0 +1,66 @@
+object Test extends App {
+
+  class TC {
+    println("TC")
+  }
+
+  class TC1
+  implied for TC1
+
+  class TV(val tc: TC) extends AnyVal
+
+  trait C {
+    val x: TC
+    implied for TC = x
+    the[TC]
+    the[TC]
+  }
+  class D extends C {
+    override val x = new TC
+  }
+
+  locally{
+    println("= new")
+    implied t for TC = new TC
+    the[TC]
+    the[TC]
+  }
+
+  locally {
+    println("= x")
+    new D
+  }
+
+  locally{
+    println("= new VC")
+    implied t for TV = new TV(new TC)
+    the[TV]
+    the[TV]
+  }
+
+  class TCC {
+    val tc: TC = new TC
+  }
+
+  val tcc = new TCC
+  locally {
+    println("= x.y")
+    implied t for TC = tcc.tc
+    the[TC]
+    the[TC]
+  }
+
+  locally {
+    println("with given")
+    implied t for TC given TC1 = new TC
+    the[TC]
+    the[TC]
+  }
+
+  locally {
+    println("with type params")
+    implied t[X] for TC = new TC
+    the[TC]
+    the[TC]
+  }
+}