Factor out isMutable logic, use it in DropGoodCasts

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/transform/localopt/Devalify.scala

@@ -10,7 +10,7 @@ import core.Types._
 import ast.Trees._
 import scala.collection.mutable
 import config.Printers.simplify
-import Simplify.desugarIdent
+import Simplify.{desugarIdent, isMutable}
 import transform.SymUtils._
 
 /** Inline vals and remove vals that are aliases to other vals
@@ -201,14 +201,8 @@ class Devalify extends Optimisation {
           readingOnlyVals(rec)
         else false
 
-      case Select(qual, _) if !t.symbol.is(Mutable) =>
-        if (t.symbol == defn.SystemModule) {
-          // System.in is static final fields that, for legacy reasons, must be
-          // allowed to be changed by the methods System.setIn...
-          // https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.5.4
-          false
-        } else
-          readingOnlyVals(qual)
+      case t @ Select(qual, _) if !isMutable(t) =>
+        readingOnlyVals(qual)
 
       case t: Ident if !t.symbol.is(Mutable | Method) && !t.symbol.info.dealias.isInstanceOf[ExprType] =>
         desugarIdent(t) match {

compiler/src/dotty/tools/dotc/transform/localopt/DropGoodCasts.scala

@@ -10,6 +10,7 @@ import core.Types._
 import core.Flags._
 import ast.Trees._
 import transform.SymUtils._
+import Simplify.isMutable
 
 /** Eliminated casts and equality tests whose results can be locally
  *  determined at compile time:
@@ -77,7 +78,8 @@ import transform.SymUtils._
 
         case TypeApply(fun @ Select(x, _), List(tp))
           if fun.symbol.eq(defn.Any_isInstanceOf) &&
-             !x.symbol.is(Method | Mutable)       &&
+             !isMutable(x)                        &&
+             !x.symbol.is(Method)                 &&
              x.symbol.exists && !x.symbol.owner.isClass =>
           (x.symbol, tp.tpe) :: Nil
 
@@ -89,14 +91,16 @@ import transform.SymUtils._
   def collectNullTests(t: Tree)(implicit ctx: Context): List[Symbol] = {
     def recur(t: Tree): List[Symbol] =
       t match {
-        case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => Nil
+        case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) =>
+          Nil
 
         case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) =>
           recur(x) ++ recur(y.head)
 
         case Apply(fun @ Select(x, _), List(tp))
             if fun.symbol.eq(defn.Object_ne)  &&
-               !x.symbol.is(Method | Mutable) &&
+               !isMutable(x)                  &&
+               !x.symbol.is(Method)           &&
                x.symbol.exists && !x.symbol.owner.isClass =>
           x.symbol :: Nil
 

compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala

@@ -146,4 +146,15 @@ object Simplify {
       case _ => None
     }
   }
+
+  // System.in is static final fields that, for legacy reasons, must be
+  // allowed to be changed by the methods System.setIn. `isMutable` is true
+  // is the field is Mutable or if it's a field of java.lang.System.
+  // https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.5.4
+  def isMutable(t: Tree)(implicit ctx: Context): Boolean = t match {
+    case _ if t.symbol.is(Mutable) => true
+    case s: Symbol => (s.symbol == defn.SystemModule)
+    case i: Ident  => desugarIdent(i).exists(isMutable)
+    case _ => false
+  }
 }