Clean up

Author: OlivierBlanvillain

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

@@ -6,13 +6,12 @@ import core.Symbols._
 import ast.Trees._
 import dotty.tools.dotc.ast.tpd
 
-/**
- * If a block has a statement that evaluates to Nothing:
- *  - Every pure statement dirrectly preceding an expression that returns Nothing can be removed,
- *  - as every statement after an expression that returns Nothing can be removed
+/** If a block has a statement that evaluates to Nothing:
+ *   - Every pure statement dirrectly preceding an expression that returns Nothing can be removed,
+ *   - as every statement after an expression that returns Nothing can be removed
  *
- * If an If condition evalutates to Nothing, the entire If can be replaced by condition
- * If an argument evaluates to Nothing, the entire call can be replaced by evaluation of arguments.
+ *  If an If condition evalutates to Nothing, the entire If can be replaced by condition
+ *  If an argument evaluates to Nothing, the entire call can be replaced by evaluation of arguments.
  *
  *  This optimisation makes it rather tricky to write meaningful examples
  *  since the compiler will often be able to reduce them to a single main
@@ -25,11 +24,7 @@ class BubbleUpNothing extends Optimisation {
 
   def visitor(implicit ctx: Context) = NoVisitor
 
-
-  /** Does the actual Tree => Tree transformation, possibly using a different
-   * context from the one used in Optimisation.
-   */
-  def transformer(implicit ctx: Context): (tpd.Tree) => tpd.Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     case t @ Apply(Select(Notathing(qual), _), args) =>
       Typed(qual, TypeTree(t.tpe))
     // This case leads to complications with multiple argument lists,

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

@@ -11,10 +11,16 @@ import Simplify.desugarIdent
 /** Various constant folding.
  *
  *  - Starts/ends with the constant folding implemented in typer (ConstFold).
+ *
  *  - Join branches if they are "similar"
- *  - regularize arithmetic and boolean expressions to have constants on the left, ie. 6 * 2 * a * 5 => 60 * a
+ *
+ *  - regularize arithmetic and boolean expressions to have constants on the
+ *    left, ie. 6 * 2 * a * 5 => 60 * a
+ *
  *  - (if) specific optimisation that propagate booleans, negation, and factor
- *    out (nested) if with equivalent branches wrt to isSimilar (using &&,||).  Dark:   ping @OlivierBlanvillain, I didn't understand this
+ *    out (nested) if with equivalent branches wrt to isSimilar. For example:
+ *      - if (b) exp else exp → b; exp
+ *      - if (b1) e1 else if (b2) e1 else e2 → if (b1 || b2) e1 else e2
  *
  *  - Constant propagation over pattern matching.
  *
@@ -209,7 +215,7 @@ import Simplify.desugarIdent
     case _ => false
   }
 
-  def isBool(tpe: Type)(implicit ctx: Context): Boolean = tpe.derivesFrom(defn.BooleanClass)
+  def isBool(tpe: Type)(implicit ctx: Context): Boolean       = tpe.derivesFrom(defn.BooleanClass)
   def isConst(tpe: Type)(implicit ctx: Context): Boolean      = tpe.isInstanceOf[ConstantType]
   def asConst(tpe: Type)(implicit ctx: Context): ConstantType = tpe.asInstanceOf[ConstantType]
 }

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

@@ -15,11 +15,12 @@ import transform.SymUtils._
 
 /** Inline vals and remove vals that are aliases to other vals
  *
- * Notion of alias is a by-value notion, so "good" casts are ignored.
+ *  Notion of alias is a by-value notion, so "good" casts are ignored.
  *
- * This phase has to be careful not to eliminate vals that are parts of other types
- * @author DarkDimius, OlivierBlanvillain
- * */
+ *  This phase has to be careful not to eliminate vals that are parts of other types
+ *
+ *  @author DarkDimius, OlivierBlanvillain
+ */
 class Devalify extends Optimisation {
   import ast.tpd._
 
@@ -98,7 +99,7 @@ class Devalify extends Optimisation {
     doVisit(tree, timesUsed)
   }
 
-  override def transformer(implicit ctx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     val valsToDrop = defined -- timesUsed.keySet -- timesUsedAsType.keySet
     val copiesToReplaceAsDuplicates = copies.filter { x =>
       val rhs = dropCasts(x._2)

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

@@ -11,7 +11,7 @@ import ast.Trees._
 import Simplify.desugarIdent
 
 /** Removes side effect free statements in blocks and Defdef.
- *  Flattens blocks(except Closure-blocks)
+ *  Flattens blocks (except Closure-blocks)
  *  Note: BoxedUnit currently messes up this phase when run after erasure
  *
  *  @author DarkDimius, OlivierBlanvillain
@@ -59,7 +59,7 @@ class DropNoEffects(val simplifyPhase: Simplify) extends Optimisation {
     case t => t
   }
 
-  def keepOnlySideEffects(t: Tree)(implicit ctx: Context):  Tree = t match {
+  def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = t match {
     case l: Literal =>
       EmptyTree
 

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

@@ -23,9 +23,9 @@ import dotty.tools.dotc.ast.tpd
 class InlineCaseIntrinsics extends Optimisation {
   import ast.tpd._
 
-  def visitor(implicit ctx: Context): (tpd.Tree) => Unit = NoVisitor
+  def visitor(implicit ctx: Context): Tree => Unit = NoVisitor
 
-  def transformer(implicit localCtx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     // For synthetic applies on case classes (both dotty/scalac)
     // - CC.apply(args) → new CC(args)
     case a: Apply

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

@@ -10,9 +10,8 @@ import config.Printers.simplify
 
 /** Inlines LabelDef which are used exactly once.
  *
- * @author DarkDimius, OlivierBlanvillain
- *         
- * */
+ *  @author DarkDimius, OlivierBlanvillain
+ */
 class InlineLabelsCalledOnce extends Optimisation {
   import ast.tpd._
 

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

@@ -13,8 +13,8 @@ import core.Flags._
 
 /** Rewrites pairs of consecutive LabelDef jumps by jumping directly to the target.
  *
- * @author DarkDimius, OlivierBlanvillain
- * */
+ *  @author DarkDimius, OlivierBlanvillain
+ */
 class Jumpjump extends Optimisation {
   import ast.tpd._
 

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

@@ -9,9 +9,7 @@ trait Optimisation {
   /** Run first to gather information on Trees (using mutation) */
   def visitor(implicit ctx: Context): Tree => Unit
 
-  /** Does the actual Tree => Tree transformation, possibly using a different
-   *  context from the one used in Optimisation.
-   */
+  /** Does the actual Tree => Tree transformation. */
   def transformer(implicit ctx: Context): Tree => Tree
 
   def name: String = this.getClass.getSimpleName

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

@@ -17,7 +17,6 @@ import scala.collection.mutable
  *  - fallsback to `tpe.isNotNull`, which will eventually be true for non nullable types.
  *  - in (a.call; a == null), the first call throws a NPE if a is null; the test can be removed.
  *
- *
  *  @author DarkDimius, Jvican, OlivierBlanvillain
  */
  class RemoveUnnecessaryNullChecks extends Optimisation {
@@ -78,7 +77,7 @@ import scala.collection.mutable
   }
 
 
-  def transformer(implicit localCtx: Context): Tree => Tree = {
+  def transformer(implicit ctx: Context): Tree => Tree = {
     def isNullLiteral(tree: Tree) = tree match {
       case literal: Literal =>
         literal.const.tag == NullTag

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

@@ -27,10 +27,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   override val cpy = tpd.cpy
 
   /** The original intention is to run most optimizations both before and after erasure.
-   * Erasure creates new inefficiencies as well as new optimization opportunities.
+   *  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.
+   *  The order of optimizations is tuned to converge faster.
+   *  Reordering them may require quadratically more rounds to finish.
    */
   private val beforeErasure: List[Optimisation] =
     new InlineCaseIntrinsics        ::
@@ -48,7 +48,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     new ConstantFold                ::
     Nil
 
-  /** see comment on  beforeErasure */
+  /** See comment on beforeErasure */
   private val afterErasure: List[Optimisation] =
     new Valify(this)                ::
     new Devalify                    ::
@@ -68,8 +68,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   var fuel: Int = -1
 
 
-  /** using fuel stops any inlining and prevents optimizations from triggering.
-   * on my tests it gives 20% slowdown, so it is going to be disabled in public builds.
+  /** Using fuel stops any inlining and prevents optimizations from triggering.
+   *  on my tests it gives 20% slowdown, so it is going to be disabled in public builds.
    */
   private final val useFuel = false
 
@@ -95,7 +95,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val ctx0 = ctx
     if (ctx.settings.optimise.value && !tree.symbol.is(Label)) {
       implicit val ctx: Context = ctx0.withOwner(tree.symbol(ctx0))
-      
+
       var rhs0 = tree.rhs
       var rhs1: Tree = null
       while (rhs1 ne rhs0) {