Sharpen condition in Inliner

Author: odersky

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

@@ -367,13 +367,19 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   }
 
   /** The purity level of this expression.
-   *  @return   SimplyPure  if expression has no side effects is a path
+   *  @return   A possibly combination of
+   *
+   *            Path        if expression is at least idempotent and is a path
+   *
    *            Pure        if expression has no side effects
    *            Idempotent  if running the expression a second time has no side effects
-   *            Impure      otherwise
    *
-   *  Note that purity and idempotency are different. References to modules and lazy
-   *  vals are impure (side-effecting) both because side-effecting code may be executed and because the first reference
+   *            Pure implies Idempotent.
+   *            Impure designates the empty combination.
+   *
+   *  Note that purity and idempotency are treated differently.
+   *  References to modules and lazy vals are impure (side-effecting) both because
+   *  side-effecting code may be executed and because the first reference
    *  takes a different code path than all to follow; but they are idempotent
    *  because running the expression a second time gives the cached result.
    */
@@ -382,12 +388,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
        | This(_)
        | Super(_, _)
        | Literal(_) =>
-      SimplyPure
+      PurePath
     case Ident(_) =>
       refPurity(tree)
     case Select(qual, _) =>
       if (tree.symbol.is(Erased)) Pure
-      else refPurity(tree).min(exprPurity(qual))
+      else refPurity(tree) `min` exprPurity(qual)
     case New(_) | Closure(_, _, _) =>
       Pure
     case TypeApply(fn, _) =>
@@ -415,37 +421,38 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       Impure
   }
 
-  private def minOf(l0: PurityLevel, ls: List[PurityLevel]) = (l0 /: ls)(_ min _)
+  private def minOf(l0: PurityLevel, ls: List[PurityLevel]) = (l0 /: ls)(_ `min` _)
 
-  def isSimplyPure(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) == SimplyPure
+  def isPurePath(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) == PurePath
   def isPureExpr(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) >= Pure
   def isIdempotentExpr(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) >= Idempotent
+  def isIdempotentPath(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) >= IdempotentPath
 
   def isPureBinding(tree: Tree)(implicit ctx: Context): Boolean = statPurity(tree) >= Pure
 
   /** The purity level of this reference.
    *  @return
-   *    SimplyPure  if reference is (nonlazy and stable) or to a parameterized function
-   *    Idempotent  if reference is lazy and stable
-   *    Impure      otherwise
+   *    PurePath        if reference is (nonlazy and stable) or to a parameterized function
+   *    IdempotentPath  if reference is lazy and stable
+   *    Impure          otherwise
    *  @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
    *               flags set.
    */
   def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel = {
     val sym = tree.symbol
     if (!tree.hasType) Impure
-    else if (!tree.tpe.widen.isParameterless || sym.isEffectivelyErased) SimplyPure
+    else if (!tree.tpe.widen.isParameterless || sym.isEffectivelyErased) PurePath
     else if (!sym.isStableMember) Impure
     else if (sym.is(Module))
-      if (sym.moduleClass.isNoInitsClass) Pure else Idempotent
-    else if (sym.is(Lazy)) Idempotent
-    else SimplyPure
+      if (sym.moduleClass.isNoInitsClass) PurePath else IdempotentPath
+    else if (sym.is(Lazy)) IdempotentPath
+    else PurePath
   }
 
   def isPureRef(tree: Tree)(implicit ctx: Context): Boolean =
-    refPurity(tree) == SimplyPure
+    refPurity(tree) == PurePath
   def isIdempotentRef(tree: Tree)(implicit ctx: Context): Boolean =
-    refPurity(tree) >= Idempotent
+    refPurity(tree) >= IdempotentPath
 
   /** (1) If `tree` is a constant expression, its value as a Literal,
    *  or `tree` itself otherwise.
@@ -840,12 +847,15 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
 object TreeInfo {
   class PurityLevel(val x: Int) extends AnyVal {
-    def >= (that: PurityLevel): Boolean = x >= that.x
-    def min(that: PurityLevel): PurityLevel = new PurityLevel(x min that.x)
+    def >= (that: PurityLevel): Boolean = (x & that.x) == that.x
+    def min(that: PurityLevel): PurityLevel = new PurityLevel(x & that.x)
   }
 
-  val SimplyPure: PurityLevel = new PurityLevel(3)
-  val Pure: PurityLevel = new PurityLevel(2)
+  val Path: PurityLevel = new PurityLevel(4)
+  val Pure: PurityLevel = new PurityLevel(3)
   val Idempotent: PurityLevel = new PurityLevel(1)
   val Impure: PurityLevel = new PurityLevel(0)
+
+  val PurePath: PurityLevel = new PurityLevel(7)
+  val IdempotentPath: PurityLevel = new PurityLevel(5)
 }

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

@@ -121,12 +121,10 @@ abstract class Lifter {
    *     val x0 = pre
    *     x0.f(...)
    *
-   *  unless `pre` is a `New` or `pre` is idempotent.
+   *  unless `pre` is idempotent.
    */
-  def liftPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(implicit ctx: Context): Tree = tree match {
-    case New(_) => tree
-    case _ => if (isIdempotentExpr(tree)) tree else lift(defs, tree)
-  }
+  def liftPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(implicit ctx: Context): Tree = 
+    if (isIdempotentExpr(tree)) tree else lift(defs, tree)
 }
 
 /** No lifting at all */
@@ -142,7 +140,7 @@ object LiftImpure extends LiftImpure
 
 /** Lift all impure or complex arguments */
 class LiftComplex extends Lifter {
-  def noLift(expr: tpd.Tree)(implicit ctx: Context): Boolean = tpd.isSimplyPure(expr)
+  def noLift(expr: tpd.Tree)(implicit ctx: Context): Boolean = tpd.isPurePath(expr)
   override def exprLifter: Lifter = LiftToDefs
 }
 object LiftComplex extends LiftComplex

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

@@ -285,7 +285,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       (tp.paramNames, tp.paramInfos, argss.head).zipped.foreach { (name, paramtp, arg) =>
         paramSpan(name) = arg.span
         paramBinding(name) = arg.tpe.dealias match {
-          case _: SingletonType if isIdempotentExpr(arg) => arg.tpe
+          case _: SingletonType if isIdempotentPath(arg) => arg.tpe
           case _ => paramBindingDef(name, paramtp, arg, bindingsBuf).symbol.termRef
         }
       }

tests/run/i6341.scala

@@ -0,0 +1,7 @@
+object Test extends App {
+  class Config(val t1: Int)
+
+  inline def m(t2:Int) = t2
+
+  m(new Config(3).t1)
+}