Cache alias implicits with lazy vals

Author: odersky

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

@@ -27,25 +27,18 @@ object CacheAliasImplicits {
  *  is cached. It applies to all alias implicits that have neither type parameters
  *  nor a given clause. Example: The alias
  *
- *      implicit a for TC = rhs
+ *      given a as TC = rhs
  *
- *  is expanded before this phase
+ *  is expanded before this phase to:
  *
  *      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
+ *  1. If `rhs` is a simple name `x` (possibly with a `this.` prefix) that
+ *     refers to a value, leave it as is.
  *
- *      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
+ *  2. Otherwise, replace the definition with
  *
  *      lazy implicit val a: TC = rhs
  */
@@ -56,47 +49,26 @@ class CacheAliasImplicits extends MiniPhase with IdentityDenotTransformer { this
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
     val sym = tree.symbol
-    sym.info match {
-      case ExprType(rhsType) if sym.is(Given, 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 _ =>
+    val rhsType = tree.rhs.tpe
+    val isCached = sym.info match {
+      case _: ExprType if sym.is(Given, butNot = CacheAliasImplicits.NoCacheFlags) =>
+        rhsType match {
+          case TermRef(NoPrefix, _)
+          if rhsType.isStable => false
+          case TermRef(pre: ThisType, _)
+          if rhsType.isStable && pre.cls == sym.owner.enclosingClass => false
+          case _ => true
         }
-        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)
-              .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
+      case _ => false
+    }
+    if (isCached) {
+      sym.copySymDenotation(
+        initFlags = sym.flags &~ Method | Lazy,
+        info = rhsType)
+      .installAfter(thisPhase)
+      cpy.ValDef(tree)(tree.name, tree.tpt, tree.rhs)
     }
+    else tree
   }
 }