Fix constant type val value inline in constructors.

Author: nicolasstucki

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

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import Flags._, Trees._, Types._, Contexts._
+import Flags._, Trees._, Types._, Contexts._, Constants._
 import Names._, StdNames._, NameOps._, Decorators._, Symbols._
 import util.HashSet
 import typer.ConstFold
@@ -426,8 +426,17 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    */
   def constToLiteral(tree: Tree)(implicit ctx: Context): Tree = {
     val tree1 = ConstFold(tree)
+    def canInlineConstant(value: Constant): Boolean = {
+      isIdempotentExpr(tree1) && // see note in documentation
+      // lazy value must be initialized (would not be needed with isPureExpr)
+      !tree1.symbol.is(Lazy) &&
+      // could hide initialization order issues (ex. val with constant type read before initialized)
+      (!ctx.owner.isLocalDummy || (tree1.symbol.is(Method) || value.isZero) ||
+        ctx.scala2Mode // ignore in Scala 2 because of inlined `final val` values
+      )
+    }
     tree1.tpe.widenTermRefExpr match {
-      case ConstantType(value) if isIdempotentExpr(tree1) && !tree1.symbol.is(Lazy) => Literal(value)
+      case ConstantType(value) if canInlineConstant(value) => Literal(value)
       case _ => tree1
     }
   }

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

@@ -53,6 +53,20 @@ object Constants {
     def isNonUnitAnyVal       = BooleanTag <= tag && tag <= DoubleTag
     def isAnyVal              = UnitTag <= tag && tag <= DoubleTag
 
+    /** Is the zero or un-initialized value of the type */
+    def isZero(implicit ctx: Context): Boolean = tag match {
+      case BooleanTag => !value.asInstanceOf[Boolean]
+      case ByteTag    => value.asInstanceOf[Byte] == 0
+      case ShortTag   => value.asInstanceOf[Short] == 0
+      case CharTag    => value.asInstanceOf[Char] == 0
+      case IntTag     => value.asInstanceOf[Int] == 0
+      case LongTag    => value.asInstanceOf[Long] == 0L
+      case FloatTag   => value.asInstanceOf[Float] == 0.0
+      case DoubleTag  => value.asInstanceOf[Double] == 0.0
+      case NullTag    => true
+      case _          => false
+    }
+
     def tpe(implicit ctx: Context): Type = tag match {
       case UnitTag    => defn.UnitType
       case BooleanTag => defn.BooleanType

compiler/test/dotc/scala-collections.blacklist

@@ -81,3 +81,5 @@ scala/util/control/Exception.scala
 # 51 |  implicit def throwableSubtypeToCatcher[Ex <: Throwable: ClassTag, T](pf: PartialFunction[Ex, T]) =
 #    |                                                                                                 ^
 #    |                                                                     cyclic reference involving method mkCatcher
+
+scala/concurrent/duration/Duration.scala

tests/run/inline-constant-in-constructor-1.check

@@ -0,0 +1,3 @@
+assert
+s
+r init

tests/run/inline-constant-in-constructor-1.scala

@@ -0,0 +1,15 @@
+
+
+abstract class A {
+  def s: Boolean = { println("s"); r }
+  def r: Boolean
+}
+
+object Test extends A {
+  assert({ println("assert"); r == s }) // r constant type not replaced by true, r not initialized yet
+  override val r: true = {
+    println("r init")
+    true
+  }
+  def main(args: Array[String]): Unit = {}
+}

tests/run/inline-constant-in-constructor-2.check

@@ -0,0 +1,3 @@
+assert
+s
+r init

tests/run/inline-constant-in-constructor-2.scala

@@ -0,0 +1,14 @@
+
+abstract class A {
+  def s: Boolean = { println("s"); r }
+  def r: Boolean
+}
+
+object Test extends A {
+  assert({ println("assert"); r == s }) // r constant type replaced by false
+  override val r: false = {
+    println("r init")
+    false
+  }
+  def main(args: Array[String]): Unit = {}
+}