Revert moving definitions to Definitions

Author: OlivierBlanvillain

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

@@ -372,8 +372,6 @@ class Definitions {
     def Seq_apply(implicit ctx: Context) = Seq_applyR.symbol
     lazy val Seq_headR = SeqClass.requiredMethodRef(nme.head)
     def Seq_head(implicit ctx: Context) = Seq_headR.symbol
-  lazy val SeqFactoryType: TypeRef = ctx.requiredClassRef("scala.collection.generic.SeqFactory")
-  def SeqFactoryClass(implicit ctx: Context) = SeqFactoryType.symbol.asClass
 
   lazy val ArrayType: TypeRef = ctx.requiredClassRef("scala.Array")
   def ArrayClass(implicit ctx: Context) = ArrayType.symbol.asClass
@@ -448,8 +446,6 @@ class Definitions {
     def Long_* = Long_mulR.symbol
     lazy val Long_divR   = LongClass.requiredMethodRef(nme.DIV, List(LongType))
     def Long_/ = Long_divR.symbol
-  val CommutativePrimitiveOperations = new PerRun[collection.Set[Symbol]](implicit ctx =>
-    Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*))
 
   lazy val FloatType: TypeRef = valueTypeRef("scala.Float", BoxedFloatType, java.lang.Float.TYPE, FloatEnc)
   def FloatClass(implicit ctx: Context) = FloatType.symbol.asClass

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

@@ -26,7 +26,7 @@ import Simplify.desugarIdent
  *
  *  @author DarkDimius, OlivierBlanvillain
  */
- class ConstantFold extends Optimisation {
+ class ConstantFold(val simplifyPhase: Simplify) extends Optimisation {
   import ast.tpd._
 
   def visitor(implicit ctx: Context) = NoVisitor
@@ -94,7 +94,7 @@ import Simplify.desugarIdent
     case t @ Apply(Select(lhs, _), List(rhs)) =>
       val sym = t.symbol
       (lhs, rhs) match {
-        case (lhs, Literal(_)) if !lhs.isInstanceOf[Literal] && defn.CommutativePrimitiveOperations().contains(sym) =>
+        case (lhs, Literal(_)) if !lhs.isInstanceOf[Literal] && simplifyPhase.CommutativePrimitiveOperations.contains(sym) =>
           rhs.select(sym).appliedTo(lhs)
 
         case (l, _) if (sym == defn.Boolean_&&) && isConst(l.tpe) =>

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

@@ -20,7 +20,7 @@ import dotty.tools.dotc.ast.tpd
  *
  *  @author DarkDimius, OlivierBlanvillain
  */
-class InlineCaseIntrinsics extends Optimisation {
+class InlineCaseIntrinsics(val simplifyPhase: Simplify) extends Optimisation {
   import ast.tpd._
 
   def visitor(implicit ctx: Context): Tree => Unit = NoVisitor
@@ -100,7 +100,7 @@ class InlineCaseIntrinsics extends Optimisation {
     // Where Seq is any companion of type <: SeqFactoryClass
     case a: Apply
       if a.symbol.name == nme.unapplySeq                  &&
-         a.symbol.owner.derivesFrom(defn.SeqFactoryClass) &&
+         a.symbol.owner.derivesFrom(simplifyPhase.SeqFactoryClass) &&
          a.symbol.extendedOverriddenSymbols.isEmpty       &&
          (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
 

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

@@ -3,10 +3,12 @@ package transform.localopt
 
 import core.Contexts.Context
 import core.DenotTransformers.IdentityDenotTransformer
+import core.Symbols._
 import core.Types._
+import core.Flags._
+import core.Decorators._
 import transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
 import config.Printers.simplify
-import core.Flags._
 import ast.tpd
 
 /** This phase consists of a series of small, simple, local optimisations
@@ -26,14 +28,17 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   override def phaseName: String = "simplify"
   override val cpy = tpd.cpy
 
+  private[localopt] var SeqFactoryClass: Symbol = null
+  private[localopt] var CommutativePrimitiveOperations: Set[Symbol] = null
+
   /** The original intention is to run most optimizations both before and after erasure.
    *  Erasure creates new inefficiencies as well as new optimization opportunities.
    *
    *  The order of optimizations is tuned to converge faster.
    *  Reordering them may require quadratically more rounds to finish.
    */
   private def beforeErasure: List[Optimisation] =
-    new InlineCaseIntrinsics        ::
+    new InlineCaseIntrinsics(this)  ::
     new RemoveUnnecessaryNullChecks ::
     new InlineOptions               ::
     new InlineLabelsCalledOnce      ::
@@ -45,7 +50,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     // new InlineLocalObjects          :: // followCases needs to be fixed, see ./tests/pos/rbtree.scala
     // new Varify                      :: // varify could stop other transformations from being applied. postponed.
     // new BubbleUpNothing             ::
-    new ConstantFold                ::
+    new ConstantFold(this)          ::
     Nil
 
   /** See comment on beforeErasure */
@@ -54,7 +59,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     new Devalify                    ::
     new Jumpjump                    ::
     new DropGoodCasts               ::
-    new ConstantFold                ::
+    new ConstantFold(this)          ::
     Nil
 
   /** Optimisation fuel, for debugging. Decremented every time Simplify
@@ -68,6 +73,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   var fuel: Int = -1
 
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
+    SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
+    CommutativePrimitiveOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*)
     val maxFuel = ctx.settings.YoptFuel.value
     if (fuel < 0 && maxFuel > 0) // Both defaults are at -1
       fuel = maxFuel