Stop emitting fields for inlined fields.

Also move final val inlining logic to Inline as mentioned in #1879.

Author: nicolasstucki

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

@@ -97,26 +97,11 @@ import Decorators._
 
     if (sym.is(Accessor, butNot = NoFieldNeeded))
       if (sym.isGetter) {
-        def skipBlocks(t: Tree): Tree = t match {
-          case Block(_, t1) => skipBlocks(t1)
-          case _ => t
-        }
-        skipBlocks(tree.rhs) match {
-          case lit: Literal if sym.is(Final, butNot = Mutable) && isIdempotentExpr(tree.rhs) =>
-            // duplicating scalac behavior: for final vals that have rhs as constant, we do not create a field
-            // and instead return the value. This seemingly minor optimization has huge effect on initialization
-            // order and the values that can be observed during superconstructor call
-
-            // see remark about idempotency in PostTyper#normalizeTree
-            cpy.DefDef(tree)(rhs = lit)
-          case _ =>
-            var rhs = tree.rhs.changeOwnerAfter(sym, field, thisTransform)
-            if (isWildcardArg(rhs)) rhs = EmptyTree
-
-            val fieldDef = transformFollowing(ValDef(field, adaptToField(rhs)))
-            val getterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(ref(field))(ctx.withOwner(sym), info))
-            Thicket(fieldDef, getterDef)
-        }
+        var rhs = tree.rhs.changeOwnerAfter(sym, field, thisTransform)
+        if (isWildcardArg(rhs)) rhs = EmptyTree
+        val fieldDef = transformFollowing(ValDef(field, adaptToField(rhs)))
+        val getterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(ref(field))(ctx.withOwner(sym), info))
+        Thicket(fieldDef, getterDef)
       } else if (sym.isSetter) {
         if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs } // this is intended as an assertion
         field.setFlag(Mutable) // necessary for vals mixed in from Scala2 traits
@@ -127,5 +112,5 @@ import Decorators._
                 // neither getters nor setters
     else tree
   }
-  private val NoFieldNeeded  = Lazy | Deferred | JavaDefined
+  private val NoFieldNeeded  = Lazy | Deferred | JavaDefined | Inline
 }

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

@@ -1173,6 +1173,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     if (sym.is(Inline, butNot = DeferredOrParamAccessor))
       checkInlineConformant(rhs1, em"right-hand side of inline $sym")
     patchIfLazy(vdef1)
+    patchFinalVals(vdef1)
     vdef1
   }
 
@@ -1185,6 +1186,32 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       patch(Position(toUntyped(vdef).pos.start), "@volatile ")
   }
 
+  /** Adds inline to final vals with idempotent rhs
+   *
+   *  duplicating scalac behavior: for final vals that have rhs as constant, we do not create a field
+   *  and instead return the value. This seemingly minor optimization has huge effect on initialization
+   *  order and the values that can be observed during superconstructor call
+   *
+   *  see remark about idempotency in PostTyper#normalizeTree
+   */
+  private def patchFinalVals(vdef: ValDef)(implicit ctx: Context): Unit = {
+    def skipBlocks(t: Tree): Tree = t match {
+      case Block(_, t1) => skipBlocks(t1)
+      case _ => t
+    }
+    def isFinalInlinableVal(sym: Symbol): Boolean = {
+      sym.is(Final, butNot = Mutable) &&
+      isIdempotentExpr(vdef.rhs) /* &&
+      ctx.scala2Mode (stay compatible with Scala2 for now) */
+    }
+    val sym = vdef.symbol
+    skipBlocks(vdef.rhs) match {
+      case lit: Literal if isFinalInlinableVal(sym) && !ctx.settings.YnoInline.value =>
+        sym.flags = sym.flags | Inline
+      case _ =>
+    }
+  }
+
   def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = track("typedDefDef") {
     val DefDef(name, tparams, vparamss, tpt, _) = ddef
     completeAnnotations(ddef, sym)