Revert "Fix #2266: Do not replace constant type lazy vals with constant."

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

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import Flags._, Trees._, Types._, Contexts._, Constants._
+import Flags._, Trees._, Types._, Contexts._
 import Names._, StdNames._, NameOps._, Decorators._, Symbols._
 import util.HashSet
 import typer.ConstFold
@@ -426,18 +426,8 @@ 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 = {
-      val sym = tree1.symbol
-      isIdempotentExpr(tree1) && // see note in documentation
-      // lazy value must be initialized (would not be needed with isPureExpr)
-      !sym.is(Lazy) &&
-      // could hide initialization order issues (ex. val with constant type read before initialized)
-      (!ctx.owner.isLocalDummy || (!sym.is(Method) && !sym.is(Lazy) && value.isZero) ||
-        ctx.scala2Mode // ignore in Scala 2 because of inlined `final val` values
-      )
-    }
     tree1.tpe.widenTermRefExpr match {
-      case ConstantType(value) if canInlineConstant(value) => Literal(value)
+      case ConstantType(value) if isIdempotentExpr(tree1) => Literal(value)
       case _ => tree1
     }
   }

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

@@ -53,20 +53,6 @@ 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/src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -9,7 +9,7 @@ import dotty.tools.dotc.transform.TreeTransforms._
 import ast.Trees._
 import Flags._
 import Types._
-import Constants._
+import Constants.Constant
 import Contexts.Context
 import Symbols._
 import SymDenotations._
@@ -34,8 +34,6 @@ import StdNames._
  *   - drops branches of ifs using the rules
  *          if (true) A else B  --> A
  *          if (false) A else B --> B
- *          if (C: true) A else B  --> C; A
- *          if (C: false) A else B  --> C; B
  */
 class FirstTransform extends MiniPhaseTransform with InfoTransformer with AnnotationTransformer { thisTransformer =>
   import ast.tpd._
@@ -192,16 +190,11 @@ class FirstTransform extends MiniPhaseTransform with InfoTransformer with Annota
   override def transformBlock(tree: Block)(implicit ctx: Context, info: TransformerInfo) =
     constToLiteral(tree)
 
-  override def transformIf(tree: If)(implicit ctx: Context, info: TransformerInfo) = {
-    tree.cond.tpe.widenTermRefExpr match {
-      case ConstantType(Constant(condVal: Boolean)) =>
-        val selected = if (condVal) tree.thenp else tree.elsep
-        if (isPureExpr(tree.cond)) selected
-        else Block(tree.cond :: Nil, selected)
-      case _ =>
-        tree
+  override def transformIf(tree: If)(implicit ctx: Context, info: TransformerInfo) =
+    tree.cond match {
+      case Literal(Constant(c: Boolean)) => if (c) tree.thenp else tree.elsep
+      case _ => tree
     }
-  }
 
   // invariants: all modules have companion objects
   // all types are TypeTrees

compiler/test/dotc/scala-collections.blacklist

@@ -81,5 +81,3 @@ 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