Constant if condition gets eliminated even when it has side-effects

[smarter]

object Test {
  if ({ println("hi"); true })
    1
  else
    2
}

Becomes, after RefChecks:

   Test$() extends Object() { 
    1
  }

There are two very wrong things here:

• This sort of optimization should be done in its own mini-phase, it has nothing to do with RefChecks
• The optimization is wrong because it only looks at the type of the condition (and check that it's a ConstantType), it should also check the purity of the tree. This should be done by sharing code with TreeInfo#constToLiteral

[LPTK]

FWIW, I have noticed a similar problem in scalac. Not sure if really related:

Welcome to the Ammonite Repl 0.5.5
(Scala 2.11.7 Java 1.8.0_65)
> import reflect.macros.whitebox.Context
import reflect.macros.whitebox.Context
> import scala.language.experimental.macros
import scala.language.experimental.macros
> object A {
  def testImpl(c: Context) = {
    import c.universe._
    val t = q"{println('ok);42}"
    println(t)
    t
  }
  def test: Int = macro testImpl
}
defined object A
> A.test
{
  println(scala.Symbol("ok"));
  42
}
'ok
res15: Int = 42
> object A {
  def testImpl(c: Context) = {
    import c.universe._
    val t = internal.setType(q"{println('ok);42}",internal.constantType(Constant(42)))
    println(t)
    t
  }
  def test: Int = macro testImpl
}
defined object A
> A.test
{
  println(scala.Symbol("ok"));
  42
}
res13: Int = 42

[smarter]

@LPTK Have you tried your example in Typelevel Scala? It contains the PR for literal constant types (scala/scala#5310) which distinguishes between FoldableConstantType (which can be constant-folded away) and LiteralType (which cannot). In dotty we only have ConstantType but we look at the purity of the corresponding tree to see if we can constant-fold or not, but we missed this case.