Don't convert given defs to vals

Author: odersky

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

@@ -66,7 +66,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 UncacheGivenAliases,    // Avoid caching RHS of simple parameterless given aliases
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
          new SpecializeApplyMethods, // Adds specialized methods to FunctionN

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

@@ -0,0 +1,67 @@
+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.Constants.Constant
+import core.Decorators._
+import core.TypeErasure.erasure
+import ast.tpd
+
+object UncacheGivenAliases:
+  val name: String = "uncacheAliasImplicits"
+
+/** This phase optimizes alias givens represented as lazy vals to be uncached
+ *  if that does not change runtime behavior. A definition does not need to be
+ *  cached if its right hand side has a stable type and is of one of them forms
+ *
+ *    this
+ *    this.y
+ *    y
+ */
+class UncacheGivenAliases extends MiniPhase with IdentityDenotTransformer:
+  thisPhase =>
+  import tpd._
+
+  override def phaseName: String = UncacheGivenAliases.name
+
+  private def needsCache(sym: Symbol, rhs: Tree)(using Context): Boolean = rhs.tpe match
+    case rhsTpe @ TermRef(NoPrefix, _)
+    if rhsTpe.isStable => false
+    case rhsTpe @ TermRef(pre: ThisType, _)
+    if rhsTpe.isStable && pre.cls == sym.owner.enclosingClass => false
+    case rhsTpe: ThisType => false
+    case _ => true
+
+  /** Transform
+   *
+   *    lazy given val x = rhs
+   *
+   *  to
+   *
+   *    def x = rhs
+   *
+   *  provided `rhs` has a stable type and is of one of them forms
+   *
+   *    this
+   *    this.y
+   *    y
+   */
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    val sym = tree.symbol
+    if sym.isAllOf(Given, Lazy) && !needsCache(sym, tree.rhs) then
+      sym.copySymDenotation(
+        initFlags = sym.flags &~ Lazy | Method,
+        info = ExprType(sym.info))
+      .installAfter(thisPhase)
+      cpy.DefDef(tree)(tree.name, Nil, Nil, tree.tpt, tree.rhs)
+    else tree
+end UncacheGivenAliases
+
+
+