Introduce readOnly purity level

We now distinguish between read-only and impure expressions. The immediate
benefits are:

 - we don't need to keep unused definitions of pattern variables whose rhs is a case
   accessor.
 - we don't need to generate code for accessors of Constant return types.

Author: odersky

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

@@ -312,6 +312,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** The purity level of this statement.
    *  @return   pure        if statement has no side effects
    *            idempotent  if running the statement a second time has no side effects
+   *            readonly    if statement has only read effects
    *            impure      otherwise
    */
   private def statPurity(tree: Tree)(implicit ctx: Context): PurityLevel = unsplice(tree) match {
@@ -331,6 +332,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** The purity level of this expression.
    *  @return   pure        if expression has no side effects
    *            idempotent  if running the expression a second time has no side effects
+   *            readonly    if statement has only read effects
    *            impure      otherwise
    *
    *  Note that purity and idempotency are different. References to modules and lazy
@@ -351,12 +353,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       refPurity(tree).min(exprPurity(qual))
     case TypeApply(fn, _) =>
       exprPurity(fn)
-/*
- * Not sure we'll need that. Comment out until we find out
-    case Apply(Select(free @ Ident(_), nme.apply), _) if free.symbol.name endsWith nme.REIFY_FREE_VALUE_SUFFIX =>
-      // see a detailed explanation of this trick in `GenSymbols.reifyFreeTerm`
-      free.symbol.hasStableFlag && isIdempotentExpr(free)
-*/
     case Apply(fn, args) =>
       def isKnownPureOp(sym: Symbol) =
         sym.owner.isPrimitiveValueClass || sym.owner == defn.StringClass
@@ -381,25 +377,31 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   def isPureExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) == Pure
   def isIdempotentExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= Idempotent
+  def isReadOnlyExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= ReadOnly
 
   /** The purity level of this reference.
    *  @return
    *    pure        if reference is (nonlazy and stable) or to a parameterized function
    *    idempotent  if reference is lazy and stable
+   *    readonly    if reference is to a val/var or to an accessor
    *    impure      otherwise
    *  @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
    *               flags set.
    */
   private def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel =
     if (!tree.tpe.widen.isParameterless) Pure
-    else if (!tree.symbol.isStable) Impure
+    else if (!tree.symbol.isStable)
+      if (!tree.symbol.is(Method) || tree.symbol.is(AnyAccessor)) ReadOnly
+      else Impure
     else if (tree.symbol.is(Lazy)) Idempotent // TODO add Module flag, sinxce Module vals or not Lazy from the start.
     else Pure
 
   def isPureRef(tree: Tree)(implicit ctx: Context) =
     refPurity(tree) == Pure
   def isIdempotentRef(tree: Tree)(implicit ctx: Context) =
     refPurity(tree) >= Idempotent
+  def isReadOnlyRef(tree: Tree)(implicit ctx: Context) =
+    refPurity(tree) >= ReadOnly
 
   /** If `tree` is a constant expression, its value as a Literal,
    *  or `tree` itself otherwise.
@@ -706,11 +708,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
 object TreeInfo {
   class PurityLevel(val x: Int) extends AnyVal {
-    def >= (that: PurityLevel) = x >= that.x
-    def min(that: PurityLevel) = new PurityLevel(x min that.x)
+    def >= (that: PurityLevel) = (x & that.x) == that.x
+    def min(that: PurityLevel) = new PurityLevel(x & that.x)
   }
 
-  val Pure = new PurityLevel(2)
+  val Pure = new PurityLevel(3)
+  val ReadOnly = new PurityLevel(2)
   val Idempotent = new PurityLevel(1)
   val Impure = new PurityLevel(0)
 }

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

@@ -479,6 +479,9 @@ object Flags {
   /** Accessors always have these flags set */
   final val AccessorCreationFlags = Method | Accessor
 
+  /** Case, Param, or field accessors */
+  final val AnyAccessor = Accessor | CaseAccessor | ParamAccessor
+
   /** Pure interfaces always have these flags */
   final val PureInterfaceCreationFlags = Trait | NoInits | PureInterface
 

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

@@ -172,7 +172,7 @@ object Erasure {
     }
 
     def constant(tree: Tree, const: Tree)(implicit ctx: Context) =
-      (if (isPureExpr(tree)) const else Block(tree :: Nil, const))
+      (if (isReadOnlyExpr(tree)) const else Block(tree :: Nil, const))
         .withPos(tree.pos)
 
     final def box(tree: Tree, target: => String = "")(implicit ctx: Context): Tree = ctx.traceIndented(i"boxing ${tree.showSummary}: ${tree.tpe} into $target") {

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

@@ -96,8 +96,7 @@ class IsInstanceOfEvaluator extends MiniPhaseTransform { thisTransformer =>
       if (to && !qualifier.tpe.isNotNull) qualifier.testNotNull
       else {
         val literal = Literal(Constant(to))
-        if (!isPureExpr(qualifier)) Block(List(qualifier), literal)
-        else literal
+        if (isReadOnlyExpr(qualifier)) literal else Block(List(qualifier), literal)
       }
 
     /** Attempts to rewrite type test to either `scrutinee ne null` or a

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

@@ -689,7 +689,7 @@ object PatternMatcher {
 
       def toDrop(sym: Symbol) = initializer.get(sym) match {
         case Some(rhs) =>
-          isPatmatGenerated(sym) && refCount(sym) <= 1 && sym != topSym && isPureExpr(rhs)
+          isPatmatGenerated(sym) && refCount(sym) <= 1 && sym != topSym && isReadOnlyExpr(rhs)
         case none =>
           false
       }

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

@@ -1724,8 +1724,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         traverse(stats ++ rest)
       case stat :: rest =>
         val stat1 = typed(stat)(ctx.exprContext(stat, exprOwner))
-        if (!ctx.isAfterTyper && isPureExpr(stat1) && !stat1.tpe.isRef(defn.UnitClass))
-          ctx.warning(em"a pure expression does nothing in statement position", stat.pos)
+        if (!ctx.isAfterTyper && isReadOnlyExpr(stat1) && !stat1.tpe.isRef(defn.UnitClass))
+          ctx.warning(em"a read-only expression does nothing in statement position", stat.pos)
         buf += stat1
         traverse(rest)
       case nil =>