Address review

Author: OlivierBlanvillain

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

@@ -72,7 +72,7 @@ class TyperState(previous: TyperState /* | Null */) {
     new TyperState(this).setReporter(new StoreReporter(reporter)).setCommittable(isCommittable)
 
   /** The uninstantiated variables */
-  def uninstVars: Seq[Types.TypeVar] = constraint.uninstVars
+  def uninstVars: Seq[TypeVar] = constraint.uninstVars
 
   /** The set of uninstantiated type variables which have this state as their owning state */
   private[this] var myOwnedVars: TypeVars = SimpleIdentitySet.empty

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

@@ -3412,7 +3412,7 @@ object Types {
   abstract case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef with SingletonType {
     type BT = TermLambda
     def kindString: String = "Term"
-    def copyBoundType(bt: BT): bt.ParamRefType = bt.paramRefs(paramNum)
+    def copyBoundType(bt: BT): Type = bt.paramRefs(paramNum)
   }
 
   private final class TermParamRefImpl(binder: TermLambda, paramNum: Int) extends TermParamRef(binder, paramNum)
@@ -3423,7 +3423,7 @@ object Types {
   abstract case class TypeParamRef(binder: TypeLambda, paramNum: Int) extends ParamRef {
     type BT = TypeLambda
     def kindString: String = "Type"
-    def copyBoundType(bt: BT): bt.ParamRefType = bt.paramRefs(paramNum)
+    def copyBoundType(bt: BT): Type = bt.paramRefs(paramNum)
 
     /** Optimized version of occursIn, avoid quadratic blowup when solving
      *  constraints over large ground types.
@@ -4875,7 +4875,7 @@ object Types {
 
   @sharable var debugTrace: Boolean = false
 
-  val watchList: List[Names.TypeName] = List[String](
+  val watchList: List[TypeName] = List[String](
   ) map (_.toTypeName)
 
   def isWatched(tp: Type)(implicit ctx: Context): Boolean = tp match {

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -68,7 +68,7 @@ class ClassfileParser(
   protected var pool: ConstantPool = _              // the classfile's constant pool
 
   protected var currentClassName: SimpleName = _      // JVM name of the current class
-  protected var classTParams: Map[Name, Symbol] = Map[Name, Symbol]()
+  protected var classTParams: Map[Name, Symbol] = Map()
 
   private[this] var Scala2UnpicklingMode = Mode.Scala2Unpickling
 

compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala

@@ -4,14 +4,14 @@ package core
 package tasty
 
 import util.Positions._
-import collection.mutable
+import collection.{mutable, Map}
 import TastyBuffer.Addr
 
 /** Unpickler for tree positions */
 class PositionUnpickler(reader: TastyReader) {
   import reader._
 
-  private[tasty] lazy val positions: mutable.HashMap[Addr, Position] = {
+  private[tasty] lazy val positions: Map[Addr, Position] = {
     val positions = new mutable.HashMap[Addr, Position]
     var curIndex = 0
     var curStart = 0

compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala

@@ -22,7 +22,7 @@ object TastyBuffer {
     def relativeTo(base: Addr): Addr = this - base.index - AddrWidth
   }
 
-  val NoAddr: TastyBuffer.Addr = Addr(-1)
+  val NoAddr: Addr = Addr(-1)
 
   /** The maximal number of address bytes.
    *  Since addresses are written as base-128 natural numbers,
@@ -41,7 +41,7 @@ import TastyBuffer._
 class TastyBuffer(initialSize: Int) {
 
   /** The current byte array, will be expanded as needed */
-  var bytes: Array[Byte] = new Array[Byte](initialSize)
+  var bytes: Array[Byte] = new Array(initialSize)
 
   /** The number of bytes written */
   var length: Int = 0
@@ -155,7 +155,7 @@ class TastyBuffer(initialSize: Int) {
   }
 
   /** The address (represented as a natural number) at address `at` */
-  def getAddr(at: Addr): TastyBuffer.Addr = Addr(getNat(at))
+  def getAddr(at: Addr): Addr = Addr(getNat(at))
 
   /** The smallest address equal to or following `at` which points to a non-zero byte */
   final def skipZeroes(at: Addr): Addr =

compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala

@@ -16,7 +16,7 @@ class TastyPickler(val rootCls: ClassSymbol) {
 
   val nameBuffer: NameBuffer = new NameBuffer
 
-  def newSection(name: String, buf: TastyBuffer): mutable.ArrayBuffer[(NameRef, TastyBuffer)] =
+  def newSection(name: String, buf: TastyBuffer): Unit =
     sections += ((nameBuffer.nameIndex(name.toTermName), buf))
 
   def assembleParts(): Array[Byte] = {

compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala

@@ -20,7 +20,7 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
 
   private[this] var bp: Int = start
 
-  def addr(idx: Int): TastyBuffer.Addr = Addr(idx - base)
+  def addr(idx: Int): Addr = Addr(idx - base)
   def index(addr: Addr): Int = addr.index + base
 
   /** The address of the first byte to read, respectively byte that was read */
@@ -105,10 +105,10 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
   }
 
   /** Read a natural number and return as a NameRef */
-  def readNameRef(): TastyBuffer.NameRef = NameRef(readNat())
+  def readNameRef(): NameRef = NameRef(readNat())
 
   /** Read a natural number and return as an address */
-  def readAddr(): TastyBuffer.Addr = Addr(readNat())
+  def readAddr(): Addr = Addr(readNat())
 
   /** Read a length number and return the absolute end address implied by it,
    *  given as <address following length field> + <length-value-read>.

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

@@ -243,7 +243,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   }
 
   /** The `decls` scope associated with given symbol */
-  protected def symScope(sym: Symbol): Scopes.Scope = symScopes.getOrElseUpdate(sym, newScope)
+  protected def symScope(sym: Symbol): Scope = symScopes.getOrElseUpdate(sym, newScope)
 
   /** Does entry represent an (internal) symbol */
   protected def isSymbolEntry(i: Int)(implicit ctx: Context): Boolean = {
@@ -611,7 +611,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       loadTypeParams
   }
 
-  def rootClassUnpickler(start: Coord, cls: Symbol, module: Symbol, infoRef: Int): ClassUnpickler with SymbolLoaders.SecondCompleter =
+  def rootClassUnpickler(start: Coord, cls: Symbol, module: Symbol, infoRef: Int): ClassUnpickler =
     (new ClassUnpickler(infoRef) with SymbolLoaders.SecondCompleter {
       override def startCoord(denot: SymDenotation): Coord = start
     }) withDecls symScope(cls) withSourceModule (_ => module)

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -265,6 +265,6 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
 }
 
 object InteractiveDriver {
-  def toUri(source: SourceFile): java.net.URI = Paths.get(source.file.path).toUri
+  def toUri(source: SourceFile): URI = Paths.get(source.file.path).toUri
 }
 

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

@@ -534,5 +534,5 @@ object JavaScanners {
     nextToken()
   }
 
-  val ((lastKeywordStart: Int), (kwArray: Array[Int])) = buildKeywordArray(keywords)
+  private val ((lastKeywordStart: Int), (kwArray: Array[Int])) = buildKeywordArray(keywords)
 }