Followup to scala#5203

Author: allanrenucci

compiler/src/dotty/tools/dotc/config/Settings.scala

@@ -193,7 +193,7 @@ object Settings {
 
   class SettingGroup {
 
-    private[this] val _allSettings: ArrayBuffer[Setting[_]] = new ArrayBuffer[Setting[_]]
+    private[this] val _allSettings = new ArrayBuffer[Setting[_]]
     def allSettings: Seq[Setting[_]] = _allSettings
 
     def defaultState: SettingsState = new SettingsState(allSettings map (_.default))

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

@@ -1952,6 +1952,7 @@ object SymDenotations {
     def apply(sym: Symbol): LazyType = this
     def apply(module: TermSymbol, modcls: ClassSymbol): LazyType = this
 
+    private[this] val NoSymbolFn = (_: Context) => NoSymbol
     private[this] var myDecls: Scope = EmptyScope
     private[this] var mySourceModuleFn: Context => Symbol = NoSymbolFn
     private[this] var myModuleClassFn: Context => Symbol = NoSymbolFn
@@ -1985,8 +1986,6 @@ object SymDenotations {
       unsupported("completerTypeParams") // should be abstract, but Scala-2 will then compute the wrong type for it
   }
 
-  val NoSymbolFn: Context => Symbol = (ctx: Context) => NoSymbol
-
   /** A missing completer */
   @sharable class NoCompleter extends LazyType {
     def complete(denot: SymDenotation)(implicit ctx: Context): Unit = unsupported("complete")

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

@@ -270,11 +270,11 @@ trait Symbols { this: Context =>
     newSymbol(cls, nme.CONSTRUCTOR, flags | Method, MethodType(paramNames, paramTypes, cls.typeRef), privateWithin, coord)
 
   /** Create an empty default constructor symbol for given class `cls`. */
-  def newDefaultConstructor(cls: ClassSymbol): Symbol =
+  def newDefaultConstructor(cls: ClassSymbol): TermSymbol =
     newConstructor(cls, EmptyFlags, Nil, Nil)
 
   /** Create a synthetic lazy implicit value */
-  def newLazyImplicit(info: Type): Symbol =
+  def newLazyImplicit(info: Type): TermSymbol =
     newSymbol(owner, LazyImplicitName.fresh(), Lazy, info)
 
   /** Create a symbol representing a selftype declaration for class `cls`. */
@@ -308,7 +308,7 @@ trait Symbols { this: Context =>
   /** Create a new skolem symbol. This is not the same as SkolemType, even though the
    *  motivation (create a singleton referencing to a type) is similar.
    */
-  def newSkolem(tp: Type): Symbol = newSymbol(defn.RootClass, nme.SKOLEM, SyntheticArtifact | NonMember | Permanent, tp)
+  def newSkolem(tp: Type): TermSymbol = newSymbol(defn.RootClass, nme.SKOLEM, SyntheticArtifact | NonMember | Permanent, tp)
 
   def newErrorSymbol(owner: Symbol, name: Name, msg: => Message): Symbol = {
     val errType = ErrorType(msg)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -758,16 +758,16 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         TempClassInfoType(until(end, () => readTypeRef()), symScope(clazz), clazz)
       case METHODtpe | IMPLICITMETHODtpe =>
         val restpe = readTypeRef()
-        val params = until(end, () => readSymbolRef()).asInstanceOf[List[Symbol]]
+        val params = until(end, () => readSymbolRef())
         def isImplicit =
           tag == IMPLICITMETHODtpe ||
           params.nonEmpty && (params.head is Implicit)
         val maker = MethodType.maker(isImplicit = isImplicit)
         maker.fromSymbols(params, restpe)
       case POLYtpe =>
         val restpe = readTypeRef()
-        val typeParams = until(end, () => readSymbolRef())
-        if (typeParams.nonEmpty) TempPolyType(typeParams.asInstanceOf[List[TypeSymbol]], restpe.widenExpr)
+        val typeParams = until(end, () => readSymbolRef()).asInstanceOf[List[TypeSymbol]]
+        if (typeParams.nonEmpty) TempPolyType(typeParams, restpe.widenExpr)
         else ExprType(restpe)
       case EXISTENTIALtpe =>
         val restpe = readTypeRef()

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

@@ -82,7 +82,7 @@ object Scanners {
 
     /** A character buffer for literals
       */
-    protected val litBuf: mutable.StringBuilder = new StringBuilder
+    protected val litBuf = new mutable.StringBuilder
 
     /** append Unicode character to "litBuf" buffer
       */
@@ -194,7 +194,7 @@ object Scanners {
     def getDocComment(pos: Int): Option[Comment] = docstringMap.get(pos)
 
     /** A buffer for comments */
-    private[this] val commentBuf: mutable.StringBuilder = new StringBuilder
+    private[this] val commentBuf = new mutable.StringBuilder
 
     private def handleMigration(keyword: Token): Token =
       if (!isScala2Mode) keyword

compiler/src/dotty/tools/dotc/printing/Highlighting.scala

@@ -31,7 +31,7 @@ object Highlighting {
   }
 
   case class HighlightBuffer(hl: Highlight)(implicit ctx: Context) {
-    private[this] val buffer: mutable.ListBuffer[String] = new mutable.ListBuffer[String]
+    private[this] val buffer = new mutable.ListBuffer[String]
 
     buffer += hl.show
 

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

@@ -90,7 +90,7 @@ class Erasure extends Phase with DenotTransformer {
       ref.derivedSingleDenotation(ref.symbol, transformInfo(ref.symbol, ref.symbol.info))
   }
 
-  private val eraser: Erasure.Typer = new Erasure.Typer(this)
+  private[this] val eraser = new Erasure.Typer(this)
 
   def run(implicit ctx: Context): Unit = {
     val unit = ctx.compilationUnit

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

@@ -23,8 +23,8 @@ class FunctionalInterfaces extends MiniPhase {
 
   def phaseName: String = FunctionalInterfaces.name
 
-  private val functionName: TermName = "JFunction".toTermName
-  private val functionPackage: TermName = "scala.compat.java8.".toTermName
+  private[this] val functionName = "JFunction".toTermName
+  private[this] val functionPackage = "scala.compat.java8.".toTermName
 
   override def transformClosure(tree: Closure)(implicit ctx: Context): Tree = {
     val cls = tree.tpe.widen.classSymbol.asClass

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

@@ -29,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)
-  private[this] val appendOffsetDefs: mutable.Map[Symbol, OffsetInfo] = mutable.Map.empty[Symbol, OffsetInfo]
+  private[this] val appendOffsetDefs = mutable.Map.empty[Symbol, OffsetInfo]
 
   override def phaseName: String = "lazyVals"
 

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 {
 
-    private[this] val nowDefinedSyms: mutable.HashSet[Symbol] = new mutable.HashSet[Symbol]
-    private[this] val everDefinedSyms: MutableSymbolMap[untpd.Tree] = newMutableSymbolMap[untpd.Tree]
+    private[this] val nowDefinedSyms = new mutable.HashSet[Symbol]
+    private[this] val everDefinedSyms = 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/Namer.scala

@@ -137,7 +137,7 @@ trait NamerContextOps { this: Context =>
         if (isJava)
           for (param <- params)
             if (param.info.isDirectRef(defn.ObjectClass)) param.info = defn.AnyType
-        make.fromSymbols(params.asInstanceOf[List[Symbol]], resultType)
+        make.fromSymbols(params, resultType)
       }
     if (typeParams.nonEmpty) PolyType.fromParams(typeParams.asInstanceOf[List[TypeSymbol]], monotpe)
     else if (valueParamss.isEmpty) ExprType(monotpe)
@@ -840,7 +840,7 @@ class Namer { typer: Typer =>
 
     val TypeDef(name, impl @ Template(constr, parents, self, _)) = original
 
-    private val ((params: List[Tree]), (rest: List[Tree])) = impl.body span {
+    private val (params, rest): (List[Tree], List[Tree]) = impl.body.span {
       case td: TypeDef => td.mods is Param
       case vd: ValDef => vd.mods is ParamAccessor
       case _ => false