Address review

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -1003,5 +1003,5 @@ object Scanners {
 
   // ------------- keyword configuration -----------------------------------
 
-  val ((lastKeywordStart: Int), (kwArray: Array[Int])) = buildKeywordArray(keywords)
+  private val ((lastKeywordStart: Int), (kwArray: Array[Int])) = buildKeywordArray(keywords)
 }

compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala

@@ -80,9 +80,9 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
   def ClassDefDeco(cdef: ClassDef): ClassDefAPI = new ClassDefAPI {
     private def rhs = cdef.rhs.asInstanceOf[tpd.Template]
     def constructor(implicit ctx: Context): DefDef = rhs.constr
-    def parents(implicit ctx: Context): List[tpd.Tree] = rhs.parents
-    def self(implicit ctx: Context): Option[tpd.ValDef] = optional(rhs.self)
-    def body(implicit ctx: Context): List[tpd.Tree] = rhs.body
+    def parents(implicit ctx: Context): List[Tree] = rhs.parents
+    def self(implicit ctx: Context): Option[ValDef] = optional(rhs.self)
+    def body(implicit ctx: Context): List[Tree] = rhs.body
   }
 
   // DefDef

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

@@ -71,7 +71,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
     }
   }
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context): FreshContext = {
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context = {
     val captured = (new CollectCaptured)
       .runOver(ctx.compilationUnit.tpdTree)(ctx.withPhase(thisPhase))
     ctx.fresh.updateStore(Captured, captured)

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

@@ -29,7 +29,7 @@ object LambdaLift {
     private type SymSet = TreeSet[Symbol]
 
     /** A map storing free variables of functions and classes */
-    val free: mutable.LinkedHashMap[Symbol, SymSet] = new LinkedHashMap[Symbol, SymSet]
+    val free: mutable.LinkedHashMap[Symbol, SymSet] = new LinkedHashMap
 
     /** A map storing the free variable proxies of functions and classes.
      *  For every function and class, this is a map from the free variables
@@ -56,7 +56,7 @@ object LambdaLift {
     private val outerParam = new HashMap[Symbol, Symbol]
 
     /** Buffers for lifted out classes and methods, indexed by owner */
-    val liftedDefs: mutable.HashMap[Symbol, mutable.ListBuffer[Tree]] = new HashMap[Symbol, mutable.ListBuffer[Tree]]
+    val liftedDefs: mutable.HashMap[Symbol, mutable.ListBuffer[Tree]] = new HashMap
 
     /** A flag to indicate whether new free variables have been found */
     private[this] var changedFreeVars: Boolean = _
@@ -516,7 +516,7 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   override def initContext(ctx: FreshContext): Unit =
     Lifter = ctx.addLocation[Lifter]()
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context): FreshContext =
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context =
     ctx.fresh.updateStore(Lifter, new Lifter(thisPhase))
 
   override def transformIdent(tree: Ident)(implicit ctx: Context): Tree = {

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

@@ -10,6 +10,7 @@ import Symbols._
 import Decorators._
 import NameKinds._
 import Types._
+import Flags.FlagSet
 import StdNames.nme
 import dotty.tools.dotc.transform.MegaPhase._
 import dotty.tools.dotc.ast.tpd
@@ -28,7 +29,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
   /** this map contains mutable state of transformation: OffsetDefs to be appended to companion object definitions,
     * and number of bits currently used */
   class OffsetInfo(var defs: List[Tree], var ord:Int)
-  val appendOffsetDefs: mutable.Map[Symbol, OffsetInfo] = mutable.Map.empty[Symbol, OffsetInfo]
+  private[this] val appendOffsetDefs: mutable.Map[Symbol, OffsetInfo] = mutable.Map.empty[Symbol, OffsetInfo]
 
   override def phaseName: String = "lazyVals"
 
@@ -40,10 +41,10 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
   def transformer: LazyVals = new LazyVals
 
-  val containerFlags: Flags.FlagSet = Flags.Synthetic | Flags.Mutable | Flags.Lazy
-  val initFlags: Flags.FlagSet      = Flags.Synthetic | Flags.Method
+  val containerFlags: FlagSet = Flags.Synthetic | Flags.Mutable | Flags.Lazy
+  val initFlags: FlagSet      = Flags.Synthetic | Flags.Method
 
-  val containerFlagsMask: Flags.FlagSet = Flags.Method | Flags.Lazy | Flags.Accessor | Flags.Module
+  val containerFlagsMask: FlagSet = Flags.Method | Flags.Lazy | Flags.Accessor | Flags.Module
 
   /** A map of lazy values to the fields they should null after initialization. */
   private[this] var lazyValNullables: IdentityHashMap[Symbol, mutable.ListBuffer[Symbol]] = _

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

@@ -98,7 +98,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
   final val PrivateOrAccessorOrDeferred: FlagSet = Private | Accessor | Deferred
 
   def forwarder(target: Symbol): List[Type] => List[List[Tree]] => Tree =
-    (targs: List[Type]) => (vrefss: List[List[Tree]]) =>
+    targs => vrefss =>
       superRef(target).appliedToTypes(targs).appliedToArgss(vrefss)
 
   private def competingMethodsIterator(meth: Symbol): Iterator[Symbol] = {

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

@@ -71,7 +71,7 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPh
     DirectMeth = ctx.addLocation[MutableSymbolMap[Symbol]]()
 
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context): FreshContext =
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context =
     ctx.fresh.updateStore(DirectMeth, newMutableSymbolMap[Symbol])
 
 

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

@@ -130,8 +130,8 @@ class TreeChecker extends Phase with SymTransformer {
 
   class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
 
-    val nowDefinedSyms: mutable.HashSet[Symbol] = new mutable.HashSet[Symbol]
-    val everDefinedSyms: MutableSymbolMap[untpd.Tree] = newMutableSymbolMap[untpd.Tree]
+    private[this] val nowDefinedSyms: mutable.HashSet[Symbol] = new mutable.HashSet[Symbol]
+    private[this] val everDefinedSyms: MutableSymbolMap[untpd.Tree] = newMutableSymbolMap[untpd.Tree]
 
     // don't check value classes after typer, as the constraint about constructors doesn't hold after transform
     override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context): Unit = ()

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

@@ -77,7 +77,7 @@ abstract class Lifter {
   /** Lift arguments that are not-idempotent into ValDefs in buffer `defs`
    *  and replace by the idents of so created ValDefs.
    */
-  def liftArgs(defs: mutable.ListBuffer[Tree], methRef: Type, args: List[Tree])(implicit ctx: Context): List[tpd.Tree] =
+  def liftArgs(defs: mutable.ListBuffer[Tree], methRef: Type, args: List[Tree])(implicit ctx: Context): List[Tree] =
     methRef.widen match {
       case mt: MethodType =>
         (args, mt.paramNames, mt.paramInfos).zipped.map { (arg, name, tp) =>
@@ -143,7 +143,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)
-  override def exprLifter: LiftToDefs.type = LiftToDefs
+  override def exprLifter: Lifter = LiftToDefs
 }
 object LiftComplex extends LiftComplex
 

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

@@ -461,8 +461,8 @@ trait Inferencing { this: Typer =>
 /** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */
 @sharable object ForceDegree {
   class Value(val appliesTo: TypeVar => Boolean, val minimizeAll: Boolean, val allowBottom: Boolean = true)
-  val none: ForceDegree.Value = new Value(_ => false, minimizeAll = false)
-  val all: ForceDegree.Value = new Value(_ => true, minimizeAll = false)
-  val noBottom: ForceDegree.Value = new Value(_ => true, minimizeAll = false, allowBottom = false)
+  val none: Value = new Value(_ => false, minimizeAll = false)
+  val all: Value = new Value(_ => true, minimizeAll = false)
+  val noBottom: Value = new Value(_ => true, minimizeAll = false, allowBottom = false)
 }