From afa630a78b4f2cd9bd799b5a0199b99548f18aaa Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 9 Apr 2015 16:57:55 +0200
Subject: Remove trailing spaces in Dotty source.

---
 src/dotty/runtime/Arrays.scala                     |   4 +-
 src/dotty/tools/dotc/ast/Desugar.scala             |   6 +-
 src/dotty/tools/dotc/ast/TreeInfo.scala            |   4 +-
 src/dotty/tools/dotc/ast/Trees.scala               |  12 +-
 src/dotty/tools/dotc/ast/tpd.scala                 |  16 +-
 src/dotty/tools/dotc/config/Config.scala           |  12 +-
 src/dotty/tools/dotc/core/Constraint.scala         |  54 +++---
 src/dotty/tools/dotc/core/ConstraintHandling.scala |  38 ++--
 src/dotty/tools/dotc/core/Contexts.scala           |   2 +-
 src/dotty/tools/dotc/core/Definitions.scala        |   6 +-
 src/dotty/tools/dotc/core/Denotations.scala        |   6 +-
 src/dotty/tools/dotc/core/Flags.scala              |  10 +-
 src/dotty/tools/dotc/core/NameOps.scala            |   4 +-
 src/dotty/tools/dotc/core/OrderingConstraint.scala | 192 ++++++++++-----------
 src/dotty/tools/dotc/core/Scopes.scala             |   8 +-
 src/dotty/tools/dotc/core/Skolemization.scala      |  30 ++--
 src/dotty/tools/dotc/core/SymDenotations.scala     |   4 +-
 src/dotty/tools/dotc/core/TypeApplications.scala   |   8 +-
 src/dotty/tools/dotc/core/TypeComparer.scala       |  32 ++--
 src/dotty/tools/dotc/core/TypeOps.scala            |   4 +-
 src/dotty/tools/dotc/core/TyperState.scala         |   2 +-
 src/dotty/tools/dotc/core/Types.scala              |  58 +++----
 .../tools/dotc/core/pickling/ClassfileParser.scala |  12 +-
 .../tools/dotc/core/pickling/DottyUnpickler.scala  |  10 +-
 .../tools/dotc/core/pickling/NameBuffer.scala      |  20 +--
 .../tools/dotc/core/pickling/PositionPickler.scala |  16 +-
 .../dotc/core/pickling/PositionUnpickler.scala     |   4 +-
 .../tools/dotc/core/pickling/TastyBuffer.scala     |  50 +++---
 src/dotty/tools/dotc/core/pickling/TastyName.scala |  10 +-
 .../tools/dotc/core/pickling/TastyPickler.scala    |  14 +-
 .../tools/dotc/core/pickling/TastyPrinter.scala    |  28 +--
 .../tools/dotc/core/pickling/TastyReader.scala     |  54 +++---
 .../tools/dotc/core/pickling/TastyUnpickler.scala  |  32 ++--
 .../tools/dotc/core/pickling/TreeBuffer.scala      |  34 ++--
 .../tools/dotc/core/pickling/TreePickler.scala     |  92 +++++-----
 .../tools/dotc/core/pickling/TreeUnpickler.scala   | 184 ++++++++++----------
 src/dotty/tools/dotc/core/pickling/UnPickler.scala |   4 +-
 src/dotty/tools/dotc/printing/PlainPrinter.scala   |  14 +-
 src/dotty/tools/dotc/printing/RefinedPrinter.scala |  24 +--
 src/dotty/tools/dotc/reporting/Reporter.scala      |   2 +-
 src/dotty/tools/dotc/transform/Constructors.scala  |   2 +-
 src/dotty/tools/dotc/transform/ElimByName.scala    |   2 +-
 src/dotty/tools/dotc/transform/ElimRepeated.scala  |   8 +-
 src/dotty/tools/dotc/transform/Erasure.scala       |  12 +-
 src/dotty/tools/dotc/transform/ExplicitOuter.scala |   6 +-
 .../tools/dotc/transform/FirstTransform.scala      |   4 +-
 .../tools/dotc/transform/NormalizeFlags.scala      |   8 +-
 src/dotty/tools/dotc/transform/Pickler.scala       |  20 +--
 src/dotty/tools/dotc/transform/ResolveSuper.scala  |   2 +-
 src/dotty/tools/dotc/transform/RestoreScopes.scala |   4 +-
 src/dotty/tools/dotc/transform/TreeChecker.scala   |   4 +-
 src/dotty/tools/dotc/typer/EtaExpansion.scala      |   2 +-
 src/dotty/tools/dotc/typer/Implicits.scala         |   2 +-
 src/dotty/tools/dotc/typer/Inferencing.scala       |   4 +-
 src/dotty/tools/dotc/typer/Mode.scala              |   6 +-
 src/dotty/tools/dotc/typer/Namer.scala             |  24 +--
 src/dotty/tools/dotc/typer/ProtoTypes.scala        |   6 +-
 src/dotty/tools/dotc/typer/TypeAssigner.scala      |   4 +-
 src/dotty/tools/dotc/typer/Typer.scala             |  10 +-
 src/dotty/tools/dotc/util/Positions.scala          |   4 +-
 src/dotty/tools/dotc/util/Util.scala               |  10 +-
 61 files changed, 630 insertions(+), 630 deletions(-)

(limited to 'src/dotty')

diff --git a/src/dotty/runtime/Arrays.scala b/src/dotty/runtime/Arrays.scala
index 0cba56d09..1fb4fe5eb 100644
--- a/src/dotty/runtime/Arrays.scala
+++ b/src/dotty/runtime/Arrays.scala
@@ -12,14 +12,14 @@ object Arrays {
    */
   def newGenericArray[T](length: Int)(implicit tag: ClassTag[T]): Array[T] =
     tag.newArray(length)
-  
+
   /** Convert a sequence to a Java array with element type given by `clazz`. */
   def seqToArray[T](xs: Seq[T], clazz: Class[_]): Array[T] = {
     val arr = java.lang.reflect.Array.newInstance(clazz, xs.length).asInstanceOf[Array[T]]
     xs.copyToArray(arr)
     arr
   }
-  
+
   /** Create an array of type T. T must be of form Array[E], with
    *  E being a reference type.
    */
diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 1dfa24291..165f4f535 100644
--- a/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/src/dotty/tools/dotc/ast/Desugar.scala
@@ -342,9 +342,9 @@ object desugar {
     val companions =
       if (mods is Case) {
         val parent =
-          if (constrTparams.nonEmpty || 
-              constrVparamss.length > 1 || 
-              mods.is(Abstract) || 
+          if (constrTparams.nonEmpty ||
+              constrVparamss.length > 1 ||
+              mods.is(Abstract) ||
               constr.mods.is(Private)) anyRef
             // todo: also use anyRef if constructor has a dependent method type (or rule that out)!
           else (constrVparamss :\ classTypeRef) ((vparams, restpe) => Function(vparams map (_.tpt), restpe))
diff --git a/src/dotty/tools/dotc/ast/TreeInfo.scala b/src/dotty/tools/dotc/ast/TreeInfo.scala
index 1bb0e0f4f..a7f89337c 100644
--- a/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -242,9 +242,9 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
    *  is an abstract typoe declaration
    */
   def lacksDefinition(mdef: MemberDef)(implicit ctx: Context) = mdef match {
-    case mdef: ValOrDefDef => 
+    case mdef: ValOrDefDef =>
       mdef.unforcedRhs == EmptyTree && !mdef.name.isConstructorName && !mdef.mods.is(ParamAccessor)
-    case mdef: TypeDef => 
+    case mdef: TypeDef =>
       mdef.rhs.isEmpty || mdef.rhs.isInstanceOf[TypeBoundsTree]
     case _ => false
   }
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index a70869e22..201c29fe1 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -76,7 +76,7 @@ object Trees {
   }
 
   private var nextId = 0 // for debugging
-  
+
   type LazyTree = AnyRef     /* really: Tree | Lazy[Tree] */
   type LazyTreeList = AnyRef /* really: List[Tree] | Lazy[List[Tree]] */
 
@@ -632,7 +632,7 @@ object Trees {
   }
 
   /** mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs */
-  case class DefDef[-T >: Untyped] private[ast] (name: TermName, tparams: List[TypeDef[T]], 
+  case class DefDef[-T >: Untyped] private[ast] (name: TermName, tparams: List[TypeDef[T]],
       vparamss: List[List[ValDef[T]]], tpt: Tree[T], private var preRhs: LazyTree)
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = DefDef[T]
@@ -761,16 +761,16 @@ object Trees {
 
   // ----- Lazy trees and tree sequences
 
-  /** A tree that can have a lazy field 
+  /** A tree that can have a lazy field
    *  The field is represented by some private `var` which is
    *  proxied `unforced` and `force`. Forcing the field will
-   *  set the `var` to the underlying value. 
+   *  set the `var` to the underlying value.
    */
   trait WithLazyField[+T <: AnyRef] {
     def unforced: AnyRef
     protected def force(x: AnyRef): Unit
     def forceIfLazy(implicit ctx: Context): T = unforced match {
-      case lzy: Lazy[T] => 
+      case lzy: Lazy[T] =>
         val x = lzy.complete
         force(x)
         x
@@ -1189,7 +1189,7 @@ object Trees {
       def apply(x: X, tree: Tree)(implicit ctx: Context): X
       def apply(x: X, trees: Traversable[Tree])(implicit ctx: Context): X = (x /: trees)(apply)
       def foldOver(x: X, tree: Tree)(implicit ctx: Context): X = {
-        def localCtx = 
+        def localCtx =
           if (tree.hasType && tree.symbol.exists) ctx.withOwner(tree.symbol) else ctx
         tree match {
           case Ident(name) =>
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 0f4585a53..20deab372 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -251,8 +251,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   def Annotated(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated =
     ta.assignType(untpd.Annotated(annot, arg), annot, arg)
-    
-  def Throw(expr: Tree)(implicit ctx: Context): Tree = 
+
+  def Throw(expr: Tree)(implicit ctx: Context): Tree =
     ref(defn.throwMethod).appliedTo(expr)
 
   // ------ Making references ------------------------------------------------------
@@ -409,7 +409,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     override def Select(tree: Tree)(qualifier: Tree, name: Name)(implicit ctx: Context): Select = {
       val tree1 = untpd.cpy.Select(tree)(qualifier, name)
       tree match {
-        case tree: Select if (qualifier.tpe eq tree.qualifier.tpe) => 
+        case tree: Select if (qualifier.tpe eq tree.qualifier.tpe) =>
           tree1.withTypeUnchecked(tree.tpe)
         case _ => tree.tpe match {
           case tpe: NamedType => tree1.withType(tpe.derivedSelect(qualifier.tpe))
@@ -609,10 +609,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       untpd.SelectWithSig(tree, name, sig)
         .withType(TermRef.withSig(tree.tpe, name.asTermName, sig))
 
-    /** A select node with selector name and signature taken from `sym`. 
+    /** A select node with selector name and signature taken from `sym`.
      *  Note: Use this method instead of select(sym) if the referenced symbol
      *  might be overridden in the type of the qualifier prefix. See note
-     *  on select(sym: Symbol). 
+     *  on select(sym: Symbol).
      */
     def selectWithSig(sym: Symbol)(implicit ctx: Context): Tree =
       selectWithSig(sym.name, sym.signature)
@@ -629,7 +629,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def appliedToArgs(args: List[Tree])(implicit ctx: Context): Apply =
       Apply(tree, args)
 
-    /** The current tree applied to given argument lists: 
+    /** The current tree applied to given argument lists:
      *  `tree (argss(0)) ... (argss(argss.length -1))`
      */
     def appliedToArgss(argss: List[List[Tree]])(implicit ctx: Context): Tree =
@@ -676,7 +676,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def or(that: Tree)(implicit ctx: Context): Tree =
       tree.select(defn.Boolean_||).appliedTo(that)
 
-    /** The translation of `tree = rhs`. 
+    /** The translation of `tree = rhs`.
      *  This is either the tree as an assignment, to a setter call.
      */
     def becomes(rhs: Tree)(implicit ctx: Context): Tree =
@@ -695,7 +695,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     // --- Higher order traversal methods -------------------------------
 
     /** Apply `f` to each subtree of this tree */
-    def foreachSubTree(f: Tree => Unit)(implicit ctx: Context): Unit = { 
+    def foreachSubTree(f: Tree => Unit)(implicit ctx: Context): Unit = {
       val traverser = new TreeTraverser {
         def traverse(tree: Tree)(implicit ctx: Context) = foldOver(f(tree), tree)
       }
diff --git a/src/dotty/tools/dotc/config/Config.scala b/src/dotty/tools/dotc/config/Config.scala
index df71bee47..6022d3580 100644
--- a/src/dotty/tools/dotc/config/Config.scala
+++ b/src/dotty/tools/dotc/config/Config.scala
@@ -14,28 +14,28 @@ object Config {
    *  does not appear at the top-level of either of its bounds.
    */
   final val checkConstraintsNonCyclic = false
-  
+
   /** Like `checkConstraintsNonCyclic`, but all constrained parameters
    *  are tested for direct or indirect dependencies, each time a
    *  constraint is added in TypeComparer.
    */
   final val checkConstraintsNonCyclicTrans = false
-  
+
   /** Check that each constraint resulting from a subtype test
    *  is satisfiable.
    */
   final val checkConstraintsSatisfiable = false
-  
+
   /** Check that each constraint is fully propagated. i.e.
    *  If P <: Q then the upper bound of P is a subtype of the upper bound of Q
    *  and the lower bound of Q is a subtype of the lower bound of P.
    */
   final val checkConstraintsPropagated = false
-  
+
   /** Type comparer will fail with an assert if the upper bound
    *  of a constrained parameter becomes Nothing. This should be turned
    *  on only for specific debugging as normally instantiation to Nothing
-   *  is not an error consdition. 
+   *  is not an error consdition.
    */
   final val failOnInstantiationToNothing = false
 
@@ -51,7 +51,7 @@ object Config {
 
   /** When explaining subtypes and this flag is set, also show the classes of the compared types. */
   final val verboseExplainSubtype = true
-  
+
   /** If this flag is set, take the fast path when comparing same-named type-aliases and types */
   final val fastPathForRefinedSubtype = true
 
diff --git a/src/dotty/tools/dotc/core/Constraint.scala b/src/dotty/tools/dotc/core/Constraint.scala
index bc0d476a9..5a758f144 100644
--- a/src/dotty/tools/dotc/core/Constraint.scala
+++ b/src/dotty/tools/dotc/core/Constraint.scala
@@ -12,16 +12,16 @@ import config.Printers._
 
 /** Constraint over undetermined type parameters. Constraints are built
  *  over values of the following types:
- *  
+ *
  *   - PolyType    A constraint constrains the type parameters of a set of PolyTypes
  *   - PolyParam   The parameters of the constrained polytypes
- *   - TypeVar     Every constrained parameter might be associated with a TypeVar 
+ *   - TypeVar     Every constrained parameter might be associated with a TypeVar
  *                 that has the PolyParam as origin.
  */
 abstract class Constraint extends Showable {
-  
+
   type This <: Constraint
-  
+
   /** Does the constraint's domain contain the type parameters of `pt`? */
   def contains(pt: PolyType): Boolean
 
@@ -30,34 +30,34 @@ abstract class Constraint extends Showable {
 
   /** Does this constraint contain the type variable `tvar` and is it uninstantiated? */
   def contains(tvar: TypeVar): Boolean
-  
+
   /** The constraint entry for given type parameter `param`, or NoType if `param` is not part of
    *  the constraint domain.
    */
   def entry(param: PolyParam): Type
-  
+
   /** The type variable corresponding to parameter `param`, or
    *  NoType, if `param` is not in constrained or is not paired with a type variable.
    */
   def typeVarOfParam(param: PolyParam): Type
-      
+
   /** Is it known that `param1 <:< param2`? */
   def isLess(param1: PolyParam, param2: PolyParam): Boolean
 
-  /** The parameters that are known to be smaller wrt <: than `param` */ 
+  /** The parameters that are known to be smaller wrt <: than `param` */
   def lower(param: PolyParam): List[PolyParam]
-  
-  /** The parameters that are known to be greater wrt <: than `param` */ 
+
+  /** The parameters that are known to be greater wrt <: than `param` */
   def upper(param: PolyParam): List[PolyParam]
-  
-  /** lower(param) \ lower(butNot) */ 
+
+  /** lower(param) \ lower(butNot) */
   def exclusiveLower(param: PolyParam, butNot: PolyParam): List[PolyParam]
-  
-  /** upper(param) \ upper(butNot) */ 
+
+  /** upper(param) \ upper(butNot) */
   def exclusiveUpper(param: PolyParam, butNot: PolyParam): List[PolyParam]
 
   /** The constraint bounds for given type parameter `param`.
-   *  Poly params that are known to be smaller or greater than `param` 
+   *  Poly params that are known to be smaller or greater than `param`
    *  are not contained in the return bounds.
    *  @pre `param` is not part of the constraint domain.
    */
@@ -65,16 +65,16 @@ abstract class Constraint extends Showable {
 
   /** The lower bound of `param` including all known-to-be-smaller parameters */
   def fullLowerBound(param: PolyParam)(implicit ctx: Context): Type
-  
+
   /** The upper bound of `param` including all known-to-be-greater parameters */
   def fullUpperBound(param: PolyParam)(implicit ctx: Context): Type
-  
+
   /** The bounds of `param` including all known-to-be-smaller and -greater parameters */
   def fullBounds(param: PolyParam)(implicit ctx: Context): TypeBounds
-  
+
   /** A new constraint which is derived from this constraint by adding
    *  entries for all type parameters of `poly`.
-   *  @param tvars   A list of type variables associated with the params, 
+   *  @param tvars   A list of type variables associated with the params,
    *                 or Nil if the constraint will just be checked for
    *                 satisfiability but will solved to give instances of
    *                 type variables.
@@ -84,15 +84,15 @@ abstract class Constraint extends Showable {
   /** A new constraint which is derived from this constraint by updating
    *  the entry for parameter `param` to `tp`.
    *  `tp` can be one of the following:
-   *  
+   *
    *   - A TypeBounds value, indicating new constraint bounds
    *   - Another type, indicating a solution for the parameter
-   * 
-   * @pre  `this contains param`.  
+   *
+   * @pre  `this contains param`.
    */
   def updateEntry(param: PolyParam, tp: Type)(implicit ctx: Context): This
-  
-  /** A constraint that includes the relationship `p1 <: p2`. 
+
+  /** A constraint that includes the relationship `p1 <: p2`.
    *  `<:` relationships between parameters ("edges") are propagated, but
    *  non-parameter bounds are left alone.
    */
@@ -113,17 +113,17 @@ abstract class Constraint extends Showable {
 
   /** Narrow one of the bounds of type parameter `param`
    *  If `isUpper` is true, ensure that `param <: `bound`, otherwise ensure
-   *  that `param >: bound`. 
+   *  that `param >: bound`.
    */
   def narrowBound(param: PolyParam, bound: Type, isUpper: Boolean)(implicit ctx: Context): This
-  
+
   /** Is entry associated with `pt` removable?
    *  @param removedParam The index of a parameter which is still present in the
    *                      entry array, but is going to be removed at the same step,
    *                      or -1 if no such parameter exists.
    */
   def isRemovable(pt: PolyType, removedParam: Int = -1): Boolean
-  
+
   /** A new constraint with all entries coming from `pt` removed. */
   def remove(pt: PolyType)(implicit ctx: Context): This
 
diff --git a/src/dotty/tools/dotc/core/ConstraintHandling.scala b/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 796960337..8caacfb2f 100644
--- a/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/src/dotty/tools/dotc/core/ConstraintHandling.scala
@@ -10,28 +10,28 @@ import config.Printers._
 /** Methods for adding constraints and solving them.
  *
  * What goes into a Constraint as opposed to a ConstrainHandler?
- * 
+ *
  * Constraint code is purely functional: Operations get constraints and produce new ones.
- * Constraint code does not have access to a type-comparer. Anything regarding lubs and glbs has to be done 
+ * Constraint code does not have access to a type-comparer. Anything regarding lubs and glbs has to be done
  * elsewhere.
- * 
+ *
  * By comparison: Constraint handlers are parts of type comparers and can use their functionality.
  * Constraint handlers update the current constraint as a side effect.
  */
 trait ConstraintHandling {
-  
+
   implicit val ctx: Context
-  
+
   protected def isSubType(tp1: Type, tp2: Type): Boolean
-  
+
   val state: TyperState
   import state.constraint
-  
+
   private var addConstraintInvocations = 0
 
   /** If the constraint is frozen we cannot add new bounds to the constraint. */
   protected var frozenConstraint = false
-   
+
   private def addOneBound(param: PolyParam, bound: Type, isUpper: Boolean): Boolean =
     !constraint.contains(param) || {
       val c1 = constraint.narrowBound(param, bound, isUpper)
@@ -57,7 +57,7 @@ trait ConstraintHandling {
     constr.println(i"added $description = $res")
     res
   }
-    
+
   protected def addLowerBound(param: PolyParam, bound: Type): Boolean = {
     def description = i"constraint $param >: $bound to\n$constraint"
     constr.println(i"adding $description")
@@ -68,11 +68,11 @@ trait ConstraintHandling {
     constr.println(i"added $description = $res")
     res
   }
- 
+
   protected def addLess(p1: PolyParam, p2: PolyParam): Boolean = {
     def description = i"ordering $p1 <: $p2 to\n$constraint"
     val res =
-      if (constraint.isLess(p2, p1)) unify(p2, p1) 
+      if (constraint.isLess(p2, p1)) unify(p2, p1)
       else {
         val down1 = p1 :: constraint.exclusiveLower(p1, p2)
         val up2 = p2 :: constraint.exclusiveUpper(p2, p1)
@@ -86,7 +86,7 @@ trait ConstraintHandling {
     constr.println(i"added $description = $res")
     res
   }
-  
+
   /** Make p2 = p1, transfer all bounds of p2 to p1
    *  @pre  less(p1)(p2)
    */
@@ -100,10 +100,10 @@ trait ConstraintHandling {
     val lo = bounds.lo
     val hi = bounds.hi
     isSubType(lo, hi) &&
-    down.forall(addOneBound(_, hi, isUpper = true)) && 
+    down.forall(addOneBound(_, hi, isUpper = true)) &&
     up.forall(addOneBound(_, lo, isUpper = false))
   }
-  
+
   protected final def isSubTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = {
     val saved = frozenConstraint
     frozenConstraint = true
@@ -164,20 +164,20 @@ trait ConstraintHandling {
     else {
       val saved = constraint
       try
-        c2.forallParams(p => 
+        c2.forallParams(p =>
           c1.contains(p) &&
           c2.upper(p).forall(c1.isLess(p, _)) &&
           isSubTypeWhenFrozen(c1.nonParamBounds(p), c2.nonParamBounds(p)))
       finally constraint = saved
     }
-  
+
   /** The current bounds of type parameter `param` */
   final def bounds(param: PolyParam): TypeBounds = constraint.entry(param) match {
     case bounds: TypeBounds => bounds
     case _ => param.binder.paramBounds(param.paramNum)
   }
-  
-  /** Add polytype `pt`, possibly with type variables `tvars`, to current constraint 
+
+  /** Add polytype `pt`, possibly with type variables `tvars`, to current constraint
    *  and propagate all bounds.
    *  @param tvars   See Constraint#add
    */
@@ -223,7 +223,7 @@ trait ConstraintHandling {
       finally addConstraintInvocations -= 1
     }
   }
-   
+
   /** Check that constraint is fully propagated. See comment in Config.checkConstraintsPropagated */
   def checkPropagated(msg: => String)(result: Boolean): Boolean = {
     if (Config.checkConstraintsPropagated && result && addConstraintInvocations == 0) {
diff --git a/src/dotty/tools/dotc/core/Contexts.scala b/src/dotty/tools/dotc/core/Contexts.scala
index 645aca601..61d4e9874 100644
--- a/src/dotty/tools/dotc/core/Contexts.scala
+++ b/src/dotty/tools/dotc/core/Contexts.scala
@@ -170,7 +170,7 @@ object Contexts {
       if (implicitsCache == null )
         implicitsCache = {
           val implicitRefs: List[TermRef] =
-            if (isClassDefContext) 
+            if (isClassDefContext)
               try owner.thisType.implicitMembers
               catch {
                 case ex: CyclicReference => Nil
diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala
index 89e4bd371..7accf9148 100644
--- a/src/dotty/tools/dotc/core/Definitions.scala
+++ b/src/dotty/tools/dotc/core/Definitions.scala
@@ -175,14 +175,14 @@ class Definitions {
 
     def ObjectMethods = List(Object_eq, Object_ne, Object_synchronized, Object_clone,
         Object_finalize, Object_notify, Object_notifyAll, Object_wait, Object_waitL, Object_waitLI)
-        
+
   /** Dummy method needed by elimByName */
   lazy val dummyApply = newPolyMethod(
       OpsPackageClass, nme.dummyApply, 1,
       pt => MethodType(List(FunctionType(Nil, PolyParam(pt, 0))), PolyParam(pt, 0)))
-      
+
   /** Method representing a throw */
-  lazy val throwMethod = newMethod(OpsPackageClass, nme.THROWkw, 
+  lazy val throwMethod = newMethod(OpsPackageClass, nme.THROWkw,
       MethodType(List(ThrowableType), NothingType))
 
   lazy val NothingClass: ClassSymbol = newCompleteClassSymbol(
diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index 849e934f0..f038e8f2f 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -476,14 +476,14 @@ object Denotations {
     /** The version of this SingleDenotation that was valid in the first phase
      *  of this run.
      */
-    def initial: SingleDenotation = 
+    def initial: SingleDenotation =
       if (validFor == Nowhere) this
       else {
         var current = nextInRun
         while (current.validFor.code > this.myValidFor.code) current = current.nextInRun
         current
       }
-      
+
     def history: List[SingleDenotation] = {
       val b = new ListBuffer[SingleDenotation]
       var current = initial
@@ -497,7 +497,7 @@ object Denotations {
 
     /** Invalidate all caches and fields that depend on base classes and their contents */
     def invalidateInheritedInfo(): Unit = ()
- 
+
     /** Move validity period of this denotation to a new run. Throw a StaleSymbol error
      *  if denotation is no longer valid.
      */
diff --git a/src/dotty/tools/dotc/core/Flags.scala b/src/dotty/tools/dotc/core/Flags.scala
index a60f7e70d..f62c3cae8 100644
--- a/src/dotty/tools/dotc/core/Flags.scala
+++ b/src/dotty/tools/dotc/core/Flags.scala
@@ -300,7 +300,7 @@ object Flags {
 
   /** Method is assumed to be stable */
   final val Stable = termFlag(24, "<stable>")
-  
+
   /** A case parameter accessor */
   final val CaseAccessor = termFlag(25, "<caseaccessor>")
 
@@ -499,7 +499,7 @@ object Flags {
 
   /** These flags are pickled */
   final val PickledFlags = flagRange(FirstFlag, FirstNotPickledFlag)
-  
+
   final val AllFlags = flagRange(FirstFlag, MaxFlag)
 
   /** An abstract class or a trait */
@@ -531,10 +531,10 @@ object Flags {
 
   /** A type parameter or type parameter accessor */
   final val TypeParamOrAccessor = TypeParam | TypeParamAccessor
-  
-  /** If symbol of a type alias has these flags, prefer the alias */ 
+
+  /** If symbol of a type alias has these flags, prefer the alias */
   final val AliasPreferred = TypeParam | TypeArgument | ExpandedName
-  
+
   /** A covariant type parameter instance */
   final val LocalCovariant = allOf(Local, Covariant)
 
diff --git a/src/dotty/tools/dotc/core/NameOps.scala b/src/dotty/tools/dotc/core/NameOps.scala
index 1834dbe64..35607cf74 100644
--- a/src/dotty/tools/dotc/core/NameOps.scala
+++ b/src/dotty/tools/dotc/core/NameOps.scala
@@ -130,7 +130,7 @@ object NameOps {
     /** If name ends in module class suffix, drop it */
     def stripModuleClassSuffix: Name =
       if (isModuleClassName) name dropRight MODULE_SUFFIX.length else name
-      
+
     /** Append a suffix so that this name does not clash with another name in the same scope */
     def avoidClashName: TermName = (name ++ AVOID_CLASH_SUFFIX).toTermName
 
@@ -161,7 +161,7 @@ object NameOps {
       val idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR)
       if (idx < 0) name else (name drop (idx + nme.EXPAND_SEPARATOR.length)).asInstanceOf[N]
     }
-    
+
     def expandedPrefix: N = {
       val idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR)
       assert(idx >= 0)
diff --git a/src/dotty/tools/dotc/core/OrderingConstraint.scala b/src/dotty/tools/dotc/core/OrderingConstraint.scala
index 0c39a26a6..21d003451 100644
--- a/src/dotty/tools/dotc/core/OrderingConstraint.scala
+++ b/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -16,10 +16,10 @@ object OrderingConstraint {
 
   /** The type of `OrderingConstraint#boundsMap` */
   type ParamBounds = SimpleMap[PolyType, Array[Type]]
-  
+
   /** The type of `OrderingConstraint#lowerMap`, `OrderingConstraint#upperMap` */
   type ParamOrdering = SimpleMap[PolyType, Array[List[PolyParam]]]
-  
+
   /** A new constraint with given maps */
   private def newConstraint(boundsMap: ParamBounds, lowerMap: ParamOrdering, upperMap: ParamOrdering)(implicit ctx: Context) : OrderingConstraint = {
     val result = new OrderingConstraint(boundsMap, lowerMap, upperMap)
@@ -27,29 +27,29 @@ object OrderingConstraint {
     ctx.runInfo.recordConstraintSize(result, result.boundsMap.size)
     result
   }
-  
+
   /** A lens for updating a single entry array in one of the three constraint maps */
   abstract class ConstraintLens[T <: AnyRef: ClassTag] {
-    def entries(c: OrderingConstraint, poly: PolyType): Array[T] 
+    def entries(c: OrderingConstraint, poly: PolyType): Array[T]
     def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[T])(implicit ctx: Context): OrderingConstraint
     def initial: T
-    
+
     def apply(c: OrderingConstraint, poly: PolyType, idx: Int) = {
       val es = entries(c, poly)
       if (es == null) initial else es(idx)
     }
- 
+
     /** The `current` constraint but with the entry for `param` updated to `entry`.
      *  `current` is used linearly. If it is different from `prev` it is
      *  known to be dead after the call. Hence it is OK to update destructively
      *  parts of `current` which are not shared by `prev`.
      */
-    def update(prev: OrderingConstraint, current: OrderingConstraint, 
+    def update(prev: OrderingConstraint, current: OrderingConstraint,
         poly: PolyType, idx: Int, entry: T)(implicit ctx: Context): OrderingConstraint = {
       var es = entries(current, poly)
       if (es != null && (es(idx) eq entry)) current
       else {
-        val result = 
+        val result =
           if (es == null) {
             es = Array.fill(poly.paramNames.length)(initial)
             updateEntries(current, poly, es)
@@ -64,40 +64,40 @@ object OrderingConstraint {
         result
       }
     }
-    
-    def update(prev: OrderingConstraint, current: OrderingConstraint, 
+
+    def update(prev: OrderingConstraint, current: OrderingConstraint,
         param: PolyParam, entry: T)(implicit ctx: Context): OrderingConstraint =
       update(prev, current, param.binder, param.paramNum, entry)
-      
-    def map(prev: OrderingConstraint, current: OrderingConstraint, 
-        poly: PolyType, idx: Int, f: T => T)(implicit ctx: Context): OrderingConstraint = 
+
+    def map(prev: OrderingConstraint, current: OrderingConstraint,
+        poly: PolyType, idx: Int, f: T => T)(implicit ctx: Context): OrderingConstraint =
      update(prev, current, poly, idx, f(apply(current, poly, idx)))
 
-    def map(prev: OrderingConstraint, current: OrderingConstraint, 
-        param: PolyParam, f: T => T)(implicit ctx: Context): OrderingConstraint = 
+    def map(prev: OrderingConstraint, current: OrderingConstraint,
+        param: PolyParam, f: T => T)(implicit ctx: Context): OrderingConstraint =
       map(prev, current, param.binder, param.paramNum, f)
   }
 
   val boundsLens = new ConstraintLens[Type] {
-    def entries(c: OrderingConstraint, poly: PolyType): Array[Type] = 
+    def entries(c: OrderingConstraint, poly: PolyType): Array[Type] =
       c.boundsMap(poly)
-    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[Type])(implicit ctx: Context): OrderingConstraint = 
+    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[Type])(implicit ctx: Context): OrderingConstraint =
       newConstraint(c.boundsMap.updated(poly, entries), c.lowerMap, c.upperMap)
     def initial = NoType
   }
-  
+
   val lowerLens = new ConstraintLens[List[PolyParam]] {
-    def entries(c: OrderingConstraint, poly: PolyType): Array[List[PolyParam]] = 
+    def entries(c: OrderingConstraint, poly: PolyType): Array[List[PolyParam]] =
       c.lowerMap(poly)
-    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint = 
+    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint =
       newConstraint(c.boundsMap, c.lowerMap.updated(poly, entries), c.upperMap)
     def initial = Nil
   }
 
   val upperLens = new ConstraintLens[List[PolyParam]] {
-    def entries(c: OrderingConstraint, poly: PolyType): Array[List[PolyParam]] = 
+    def entries(c: OrderingConstraint, poly: PolyType): Array[List[PolyParam]] =
       c.upperMap(poly)
-    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint = 
+    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint =
       newConstraint(c.boundsMap, c.lowerMap, c.upperMap.updated(poly, entries))
     def initial = Nil
   }
@@ -105,7 +105,7 @@ object OrderingConstraint {
 
 import OrderingConstraint._
 
-/** Constraint over undetermined type parameters that keeps separate maps to 
+/** Constraint over undetermined type parameters that keeps separate maps to
  *  reflect parameter orderings.
  *  @param boundsMap a map from PolyType to arrays.
  *               Each array contains twice the number of entries as there a type parameters
@@ -115,23 +115,23 @@ import OrderingConstraint._
  *               An instantiated type parameter is represented by having its instance type in
  *               the corresponding array entry. The dual use of arrays for poly params
  *               and typevars is to save space and hopefully gain some speed.
- *               
+ *
  *  @param lowerMap a map from PolyTypes to arrays. Each array entry corresponds
  *               to a parameter P of the polytype; it contains all constrained parameters
- *               Q that are known to be smaller than P, i.e. Q <: P. 
+ *               Q that are known to be smaller than P, i.e. Q <: P.
  *  @param upperMap a map from PolyTypes to arrays. Each array entry corresponds
  *               to a parameter P of the polytype; it contains all constrained parameters
- *               Q that are known to be greater than P, i.e. P <: Q. 
+ *               Q that are known to be greater than P, i.e. P <: Q.
  */
-class OrderingConstraint(private val boundsMap: ParamBounds, 
-                         private val lowerMap : ParamOrdering, 
+class OrderingConstraint(private val boundsMap: ParamBounds,
+                         private val lowerMap : ParamOrdering,
                          private val upperMap : ParamOrdering) extends Constraint {
-  
+
   type This = OrderingConstraint
-    
-  
+
+
 // ----------- Basic indices --------------------------------------------------
-  
+
   /** The number of type parameters in the given entry array */
   private def paramCount(entries: Array[Type]) = entries.length >> 1
 
@@ -145,7 +145,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     if (entries == null) NoType
     else entries(param.paramNum)
   }
-    
+
 // ----------- Contains tests --------------------------------------------------
 
   def contains(pt: PolyType): Boolean = boundsMap(pt) != null
@@ -163,42 +163,42 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
   }
 
   private def isBounds(tp: Type) = tp.isInstanceOf[TypeBounds]
-  
+
 // ---------- Dependency handling ----------------------------------------------
-    
+
   def lower(param: PolyParam): List[PolyParam] = lowerLens(this, param.binder, param.paramNum)
   def upper(param: PolyParam): List[PolyParam] = upperLens(this, param.binder, param.paramNum)
-    
+
   def minLower(param: PolyParam): List[PolyParam] = {
     val all = lower(param)
     all.filterNot(p => all.exists(isLess(p, _)))
   }
-  
+
   def minUpper(param: PolyParam): List[PolyParam] = {
     val all = upper(param)
     all.filterNot(p => all.exists(isLess(_, p)))
   }
-  
+
   def exclusiveLower(param: PolyParam, butNot: PolyParam): List[PolyParam] =
     lower(param).filterNot(isLess(_, butNot))
-    
+
   def exclusiveUpper(param: PolyParam, butNot: PolyParam): List[PolyParam] =
     upper(param).filterNot(isLess(butNot, _))
-  
+
 // ---------- Info related to PolyParams -------------------------------------------
 
   def isLess(param1: PolyParam, param2: PolyParam): Boolean =
     upper(param1).contains(param2)
 
-  def nonParamBounds(param: PolyParam): TypeBounds = 
+  def nonParamBounds(param: PolyParam): TypeBounds =
     entry(param).asInstanceOf[TypeBounds]
-    
+
   def fullLowerBound(param: PolyParam)(implicit ctx: Context): Type =
     (nonParamBounds(param).lo /: minLower(param))(_ | _)
 
-  def fullUpperBound(param: PolyParam)(implicit ctx: Context): Type = 
+  def fullUpperBound(param: PolyParam)(implicit ctx: Context): Type =
     (nonParamBounds(param).hi /: minUpper(param))(_ & _)
-    
+
   def fullBounds(param: PolyParam)(implicit ctx: Context): TypeBounds =
     nonParamBounds(param).derivedTypeBounds(fullLowerBound(param), fullUpperBound(param))
 
@@ -209,17 +209,17 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       val tvar = typeVar(entries, param.paramNum)
       if (tvar != null) tvar else NoType
     }
-  }  
+  }
 
 // ---------- Adding PolyTypes --------------------------------------------------
-   
+
   /** The list of parameters P such that, for a fresh type parameter Q:
-   *  
+   *
    *    Q <: tp  implies  Q <: P      and isUpper = true, or
    *    tp <: Q  implies  P <: Q      and isUpper = false
    */
   def dependentParams(tp: Type, isUpper: Boolean): List[PolyParam] = tp match {
-    case param: PolyParam if contains(param) => 
+    case param: PolyParam if contains(param) =>
       param :: (if (isUpper) upper(param) else lower(param))
     case tp: AndOrType =>
       val ps1 = dependentParams(tp.tp1, isUpper)
@@ -228,7 +228,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     case _ =>
       Nil
   }
-  
+
   /** The bound type `tp` without constrained parameters which are clearly
    *  dependent. A parameter in an upper bound is clearly dependent if it appears
    *  in a hole of a context H given by:
@@ -237,7 +237,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *          H & T
    *          T & H
    *
-   *  (the idea is that a parameter P in a H context is guaranteed to be a supertype of the 
+   *  (the idea is that a parameter P in a H context is guaranteed to be a supertype of the
    *   bounded parameter.)
    *  Analogously, a parameter in a lower bound is clearly dependent if it appears
    *  in a hole of a context H given by:
@@ -245,18 +245,18 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *      L = []
    *          L | T
    *          T | L
-   *     
+   *
    *  "Clearly dependent" is not synonymous with "dependent" in the sense
    *  it is defined in `dependentParams`. Dependent parameters are handled
    *  in `updateEntry`. The idea of stripping off clearly dependent parameters
-   *  and to handle them separately is for efficiency, so that type expressions 
+   *  and to handle them separately is for efficiency, so that type expressions
    *  used as bounds become smaller.
-   *  
+   *
    *  @param isUpper   If true, `bound` is an upper bound, else a lower bound.
    */
-  private def stripParams(tp: Type, paramBuf: mutable.ListBuffer[PolyParam], 
+  private def stripParams(tp: Type, paramBuf: mutable.ListBuffer[PolyParam],
       isUpper: Boolean)(implicit ctx: Context): Type = tp match {
-    case param: PolyParam if contains(param) => 
+    case param: PolyParam if contains(param) =>
       if (!paramBuf.contains(param)) paramBuf += param
       NoType
     case tp: AndOrType if isUpper == tp.isAnd =>
@@ -268,17 +268,17 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       else tp2
     case _ =>
       tp
-  } 
-  
+  }
+
   /** The bound type `tp` without clearly dependent parameters.
    *  A top or bottom type if type consists only of dependent parameters.
    *  @param isUpper   If true, `bound` is an upper bound, else a lower bound.
    */
-  private def normalizedType(tp: Type, paramBuf: mutable.ListBuffer[PolyParam], 
-      isUpper: Boolean)(implicit ctx: Context): Type = 
+  private def normalizedType(tp: Type, paramBuf: mutable.ListBuffer[PolyParam],
+      isUpper: Boolean)(implicit ctx: Context): Type =
     stripParams(tp, paramBuf, isUpper)
       .orElse(if (isUpper) defn.AnyType else defn.NothingType)
-  
+
   def add(poly: PolyType, tvars: List[TypeVar])(implicit ctx: Context): This = {
     assert(!contains(poly))
     val nparams = poly.paramNames.length
@@ -287,7 +287,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     tvars.copyToArray(entries1, nparams)
     newConstraint(boundsMap.updated(poly, entries1), lowerMap, upperMap).init(poly)
   }
-    
+
   /** Split dependent parameters off the bounds for parameters in `poly`.
    *  Update all bounds to be normalized and update ordering to account for
    *  dependent parameters.
@@ -311,9 +311,9 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     if (Config.checkConstraintsNonCyclic) checkNonCyclic()
     current
   }
-  
+
 // ---------- Updates ------------------------------------------------------------
-  
+
   /** Add the fact `param1 <: param2` to the constraint `current` and propagate
    *  `<:<` relationships between parameters ("edges") but not bounds.
    */
@@ -331,31 +331,31 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   def addLess(param1: PolyParam, param2: PolyParam)(implicit ctx: Context): This =
     order(this, param1, param2)
-    
+
   def updateEntry(current: This, param: PolyParam, tp: Type)(implicit ctx: Context): This = {
     var current1 = boundsLens.update(this, current, param, tp)
     tp match {
       case TypeBounds(lo, hi) =>
-        for (p <- dependentParams(lo, isUpper = false)) 
+        for (p <- dependentParams(lo, isUpper = false))
           current1 = order(current1, p, param)
-        for (p <- dependentParams(hi, isUpper = true)) 
+        for (p <- dependentParams(hi, isUpper = true))
           current1 = order(current1, param, p)
       case _ =>
     }
     current1
   }
-      
+
   def updateEntry(param: PolyParam, tp: Type)(implicit ctx: Context): This =
     updateEntry(this, param, tp)
-    
+
   def unify(p1: PolyParam, p2: PolyParam)(implicit ctx: Context): This = {
     val p1Bounds = (nonParamBounds(p1) & nonParamBounds(p2)).substParam(p2, p1)
     updateEntry(p1, p1Bounds).replace(p2, p1)
   }
-  
+
   def narrowBound(param: PolyParam, bound: Type, isUpper: Boolean)(implicit ctx: Context): This = {
-    val oldBounds @ TypeBounds(lo, hi) = nonParamBounds(param) 
-    val newBounds = 
+    val oldBounds @ TypeBounds(lo, hi) = nonParamBounds(param)
+    val newBounds =
       if (isUpper) oldBounds.derivedTypeBounds(lo, hi & bound)
       else oldBounds.derivedTypeBounds(lo | bound, hi)
     updateEntry(param, newBounds)
@@ -368,40 +368,40 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *  of the parameter elsewhere in the constraint by type `tp`, or a conservative
    *  approximation of it if that is needed to avoid cycles.
    *  Occurrences nested inside a refinement or prefix are not affected.
-   *  
+   *
    *  The reason we need to substitute top-level occurrences of the parameter
    *  is to deal with situations like the following. Say we have in the constraint
-   *  
+   *
    *      P <: Q & String
    *      Q
-   *      
+   *
    *  and we replace Q with P. Then substitution gives
-   *  
+   *
    *      P <: P & String
-   *      
+   *
    *  this would be a cyclic constraint is therefore changed by `normalize` and
    *  `recombine` below to
-   *  
+   *
    *      P <: String
-   *      
-   *  approximating the RHS occurrence of P with Any. Without the substitution we 
+   *
+   *  approximating the RHS occurrence of P with Any. Without the substitution we
    *  would not find out where we need to approximate. Occurrences of parameters
    *  that are not top-level are not affected.
    */
   def replace(param: PolyParam, tp: Type)(implicit ctx: Context): OrderingConstraint = {
     val replacement = tp.dealias.stripTypeVar
-    if (param == replacement) this 
+    if (param == replacement) this
     else {
       assert(replacement.isValueType)
       val poly = param.binder
       val idx = param.paramNum
-      
-      def removeParam(ps: List[PolyParam]) = 
+
+      def removeParam(ps: List[PolyParam]) =
         ps.filterNot(p => p.binder.eq(poly) && p.paramNum == idx)
-        
+
       def replaceParam(tp: Type, atPoly: PolyType, atIdx: Int) = tp match {
         case bounds @ TypeBounds(lo, hi) =>
-                    
+
           def recombine(andor: AndOrType, op: (Type, Boolean) => Type, isUpper: Boolean): Type = {
             val tp1 = op(andor.tp1, isUpper)
             val tp2 = op(andor.tp2, isUpper)
@@ -409,7 +409,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
             else if (andor.isAnd) tp1 & tp2
             else tp1 | tp2
           }
-           
+
           def normalize(tp: Type, isUpper: Boolean): Type = tp match {
             case p: PolyParam if p.binder == atPoly && p.paramNum == atIdx =>
               if (isUpper) defn.AnyType else defn.NothingType
@@ -422,12 +422,12 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
             case tp: AndOrType if isUpper == tp.isAnd => recombine(tp, replaceIn, isUpper)
             case _ => tp
           }
-          
+
           bounds.derivedTypeBounds(replaceIn(lo, isUpper = false), replaceIn(hi, isUpper = true))
         case _ => tp
       }
-      
-      var current = 
+
+      var current =
         if (isRemovable(poly, idx)) remove(poly) else updateEntry(param, replacement)
       current.foreachParam {(p, i) =>
         current = boundsLens.map(this, current, p, i, replaceParam(_, p, i))
@@ -438,7 +438,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     }
   }
 
-  def remove(pt: PolyType)(implicit ctx: Context): This = 
+  def remove(pt: PolyType)(implicit ctx: Context): This =
     newConstraint(boundsMap.remove(pt), lowerMap.remove(pt), upperMap.remove(pt))
 
   def isRemovable(pt: PolyType, removedParam: Int = -1): Boolean = {
@@ -461,7 +461,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   def domainPolys: List[PolyType] = boundsMap.keys
 
-  def domainParams: List[PolyParam] = 
+  def domainParams: List[PolyParam] =
     for {
       (poly, entries) <- boundsMap.toList
       n <- 0 until paramCount(entries)
@@ -475,7 +475,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     }
     true
   }
-  
+
   def foreachParam(p: (PolyType, Int) => Unit): Unit =
     boundsMap.foreachBinding { (poly, entries) =>
       0.until(poly.paramNames.length).foreach(p(poly, _))
@@ -513,17 +513,17 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   def checkNonCyclic()(implicit ctx: Context): Unit =
     domainParams.foreach(checkNonCyclic)
-  
+
   private def checkNonCyclic(param: PolyParam)(implicit ctx: Context): Unit =
     assert(!isLess(param, param), i"cyclic constraint involving $param in $this")
-  
+
 // ---------- toText -----------------------------------------------------
 
   override def toText(printer: Printer): Text = {
     def entryText(tp: Type) = tp match {
-      case tp: TypeBounds => 
+      case tp: TypeBounds =>
         tp.toText(printer)
-      case _ => 
+      case _ =>
         " := " ~ tp.toText(printer)
     }
     val indent = 3
@@ -547,7 +547,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
             ups = minUpper(param)
             if ups.nonEmpty
           }
-          yield 
+          yield
             (" " * indent) ~ param.toText(printer) ~ " <: " ~
               Text(ups.map(_.toText(printer)), ", ")
         Text(deps, "\n")
diff --git a/src/dotty/tools/dotc/core/Scopes.scala b/src/dotty/tools/dotc/core/Scopes.scala
index 70bcbdee6..ad9ba4201 100644
--- a/src/dotty/tools/dotc/core/Scopes.scala
+++ b/src/dotty/tools/dotc/core/Scopes.scala
@@ -93,7 +93,7 @@ object Scopes {
 
     /** Lookup next entry with same name as this one */
     def lookupNextEntry(entry: ScopeEntry)(implicit ctx: Context): ScopeEntry
-    
+
     /** Lookup a symbol */
     final def lookup(name: Name)(implicit ctx: Context): Symbol = {
       val e = lookupEntry(name)
@@ -138,9 +138,9 @@ object Scopes {
     }
 
     def implicitDecls(implicit ctx: Context): List[TermRef] = Nil
-    
+
     def openForMutations: MutableScope = unsupported("openForMutations")
-    
+
     final def toText(printer: Printer): Text = printer.toText(this)
   }
 
@@ -376,7 +376,7 @@ object Scopes {
       }
       syms
     }
-    
+
     override def openForMutations: MutableScope = this
   }
 
diff --git a/src/dotty/tools/dotc/core/Skolemization.scala b/src/dotty/tools/dotc/core/Skolemization.scala
index 1d0067a4f..fb47cb62a 100644
--- a/src/dotty/tools/dotc/core/Skolemization.scala
+++ b/src/dotty/tools/dotc/core/Skolemization.scala
@@ -5,42 +5,42 @@ import Symbols._, Types._, Contexts._
 import collection.mutable
 
 /** Methods to add and remove skolemtypes.
- *  
- *  Skolem types are generated when comparing refinements. 
+ *
+ *  Skolem types are generated when comparing refinements.
  *  A skolem type is simply a fresh singleton type that has a given type
  *  as underlying type.
- *  Two skolem types are equal if they refer to the same underlying type. 
+ *  Two skolem types are equal if they refer to the same underlying type.
  *  To avoid unsoundness, skolem types have to be kept strictly local to the
  *  comparison, they are not allowed to escape the lifetime of a comparison
- *  by surviving in a context or in GADT bounds. 
+ *  by surviving in a context or in GADT bounds.
  */
 trait Skolemization {
-  
+
   implicit val ctx: Context
 
   protected var skolemsOutstanding = false
-  
+
   def ensureStableSingleton(tp: Type): SingletonType = tp.stripTypeVar match {
-    case tp: SingletonType if tp.isStable => 
+    case tp: SingletonType if tp.isStable =>
       tp
-    case tp: ValueType => 
+    case tp: ValueType =>
       skolemsOutstanding = true
       SkolemType(tp)
-    case tp: TypeProxy => 
+    case tp: TypeProxy =>
       ensureStableSingleton(tp.underlying)
   }
-    
+
   /** Approximate a type `tp` with a type that does not contain skolem types.
    *  @param  toSuper   if true, return the smallest supertype of `tp` with this property
    *                    else return the largest subtype.
    */
-  final def deSkolemize(tp: Type, toSuper: Boolean): Type = 
-    if (skolemsOutstanding) deSkolemize(tp, if (toSuper) 1 else -1, Set()) 
+  final def deSkolemize(tp: Type, toSuper: Boolean): Type =
+    if (skolemsOutstanding) deSkolemize(tp, if (toSuper) 1 else -1, Set())
     else tp
 
   private def deSkolemize(tp: Type, variance: Int, seen: Set[SkolemType]): Type =
     ctx.traceIndented(s"deskolemize $tp, variance = $variance, seen = $seen  =  ") {
-    def approx(lo: Type = defn.NothingType, hi: Type = defn.AnyType, newSeen: Set[SkolemType] = seen) = 
+    def approx(lo: Type = defn.NothingType, hi: Type = defn.AnyType, newSeen: Set[SkolemType] = seen) =
       if (variance == 0) NoType
       else deSkolemize(if (variance < 0) lo else hi, variance, newSeen)
     tp match {
@@ -71,7 +71,7 @@ trait Skolemization {
             tp.derivedRefinedType(parent1, tp.refinedName, refinedInfo1)
           else
             approx(hi = parent1)
-        } 
+        }
         else approx()
       case tp: TypeAlias =>
         val alias1 = deSkolemize(tp.alias, variance * tp.variance, seen)
@@ -107,7 +107,7 @@ trait Skolemization {
         deSkolemizeMap.mapOver(tp, variance, seen)
     }
   }
-  
+
   object deSkolemizeMap extends TypeMap {
     private var seen: Set[SkolemType] = _
     def apply(tp: Type) = deSkolemize(tp, variance, seen)
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index e572f129b..3566595f2 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -43,7 +43,7 @@ trait SymDenotations { this: Context =>
     if (denot is ValidForever) true
     else {
       val initial = denot.initial
-      if (initial ne denot) 
+      if (initial ne denot)
         ctx.withPhase(initial.validFor.firstPhaseId).stillValid(initial.asSymDenotation)
       else try {
         val owner = denot.owner.denot
@@ -79,7 +79,7 @@ object SymDenotations {
       super.validFor_=(p)
     }
     */
-    
+
     // ------ Getting and setting fields -----------------------------
 
     private[this] var myFlags: FlagSet = adaptFlags(initFlags)
diff --git a/src/dotty/tools/dotc/core/TypeApplications.scala b/src/dotty/tools/dotc/core/TypeApplications.scala
index f08183b67..df18813b9 100644
--- a/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -191,8 +191,8 @@ class TypeApplications(val self: Type) extends AnyVal {
       if (res.isInstantiatedLambda) res.select(tpnme.Apply) else res
     }
   }
-  
-  /** Simplify a fully instantiated type of the form `LambdaX{... type Apply = T } # Apply` to `T`. 
+
+  /** Simplify a fully instantiated type of the form `LambdaX{... type Apply = T } # Apply` to `T`.
    */
   def simplifyApply(implicit ctx: Context): Type = self match {
     case self @ TypeRef(prefix, tpnme.Apply) if prefix.isInstantiatedLambda =>
@@ -383,7 +383,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     case JavaArrayType(elemtp) => elemtp
     case _ => firstBaseArgInfo(defn.SeqClass)
   }
-  
+
   def containsSkolemType(target: Type)(implicit ctx: Context): Boolean = {
     def recur(tp: Type): Boolean = tp.stripTypeVar match {
       case SkolemType(tp) =>
@@ -404,7 +404,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case _ =>
         false
     }
-    recur(self) 
+    recur(self)
   }
 
   /** Given a type alias
diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala
index 1687d6159..a59a64a91 100644
--- a/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -163,7 +163,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
                  // Dealiasing is taken care of elsewhere.
                  val pre1 = tp1.prefix
                  val pre2 = tp2.prefix
-                 isSameType(pre1, pre2) || 
+                 isSameType(pre1, pre2) ||
                    sym1.isClass &&
                    pre2.classSymbol.exists &&
                    pre2.abstractTypeMembers.isEmpty &&
@@ -176,11 +176,11 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
               !tp1.isInstanceOf[WithFixedSym] &&
               !tp2.isInstanceOf[WithFixedSym]
             ) ||
-            compareHK(tp1, tp2, inOrder = true) || 
+            compareHK(tp1, tp2, inOrder = true) ||
             compareHK(tp2, tp1, inOrder = false) ||
             compareAlias(tp1.info)
           case _ =>
-            compareHK(tp2, tp1, inOrder = false) || 
+            compareHK(tp2, tp1, inOrder = false) ||
             compareAlias(NoType)
         }
       }
@@ -312,7 +312,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
       }
       fourthTry(tp1, tp2)
   }
-  
+
   private def thirdTry(tp1: Type, tp2: Type): Boolean = tp2 match {
     case tp2: NamedType =>
       thirdTryNamed(tp1, tp2)
@@ -453,7 +453,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
         case JavaArrayType(elem2) => isSubType(elem1, elem2)
         case _ => tp2 isRef ObjectClass
       }
-      compareJavaArray 
+      compareJavaArray
     case _ =>
       false
   }
@@ -518,7 +518,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
       false
     } else isSubType(tp1, tp2)
 
-  /** Does type `tp1` have a member with name `name` whose normalized type is a subtype of 
+  /** Does type `tp1` have a member with name `name` whose normalized type is a subtype of
    *  the normalized type of the refinement `tp2`?
    *  Normalization is as follows: If `tp2` contains a skolem to its refinement type,
    *  rebase both itself and the member info of `tp` on a freshly created skolem type.
@@ -552,16 +552,16 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
   }
 
   /** Skip refinements in `tp2` which match corresponding refinements in `tp1`.
-   *  "Match" means: 
-   *   - they appear in the same order, 
-   *   - they refine the same names, 
-   *   - the refinement in `tp1` is an alias type, and 
+   *  "Match" means:
+   *   - they appear in the same order,
+   *   - they refine the same names,
+   *   - the refinement in `tp1` is an alias type, and
    *   - neither refinement refers back to the refined type via a refined this.
    *  @return  The parent type of `tp2` after skipping the matching refinements.
    */
   private def skipMatching(tp1: Type, tp2: RefinedType): Type = tp1 match {
     case tp1 @ RefinedType(parent1, name1)
-    if name1 == tp2.refinedName && 
+    if name1 == tp2.refinedName &&
        tp1.refinedInfo.isInstanceOf[TypeAlias] &&
        !tp2.refinementRefersToThis &&
        !tp1.refinementRefersToThis =>
@@ -672,7 +672,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
         case _: PolyType =>
           false
         case tp2: MethodType =>
-          relaxed && tp2.paramNames.isEmpty && 
+          relaxed && tp2.paramNames.isEmpty &&
             matchesType(tp1, tp2.resultType, relaxed)
         case tp2 =>
           relaxed || isSameType(tp1, tp2)
@@ -1118,15 +1118,15 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
   def copyIn(ctx: Context) = new TypeComparer(ctx)
 
   // ----------- Diagnostics --------------------------------------------------
-  
+
   /** A hook for showing subtype traces. Overridden in ExplainingTypeComparer */
   def traceIndented[T](str: String)(op: => T): T = op
-    
+
   private def traceInfo(tp1: Type, tp2: Type) =
     s"${tp1.show} <:< ${tp2.show}" + {
       if (ctx.settings.verbose.value || Config.verboseExplainSubtype) {
-        s" ${tp1.getClass}, ${tp2.getClass}" + 
-        (if (frozenConstraint) " frozen" else "") + 
+        s" ${tp1.getClass}, ${tp2.getClass}" +
+        (if (frozenConstraint) " frozen" else "") +
         (if (ctx.mode is Mode.TypevarsMissContext) " tvars-miss-ctx" else "")
       }
       else ""
diff --git a/src/dotty/tools/dotc/core/TypeOps.scala b/src/dotty/tools/dotc/core/TypeOps.scala
index e6a81248c..2b6ea49e8 100644
--- a/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/src/dotty/tools/dotc/core/TypeOps.scala
@@ -86,7 +86,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   class SimplifyMap extends TypeMap {
     def apply(tp: Type) = simplify(tp, this)
   }
-  
+
   /** Approximate union type by intersection of its dominators.
    *  See Type#approximateUnion for an explanation.
    */
@@ -330,7 +330,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     }
     parentRefs
   }
-  
+
   /** An argument bounds violation is a triple consisting of
    *   - the argument tree
    *   - a string "upper" or "lower" indicating which bound is violated
diff --git a/src/dotty/tools/dotc/core/TyperState.scala b/src/dotty/tools/dotc/core/TyperState.scala
index 1079af510..91cda1dd8 100644
--- a/src/dotty/tools/dotc/core/TyperState.scala
+++ b/src/dotty/tools/dotc/core/TyperState.scala
@@ -17,7 +17,7 @@ class TyperState(r: Reporter) extends DotClass with Showable {
   def reporter = r
 
   /** The current constraint set */
-  def constraint: Constraint = 
+  def constraint: Constraint =
     new OrderingConstraint(SimpleMap.Empty, SimpleMap.Empty, SimpleMap.Empty)
   def constraint_=(c: Constraint): Unit = {}
 
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index 31567fee0..802a4e406 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -471,7 +471,7 @@ object Types {
             go(bounds.hi)
           case _ =>
             go(next)
-        }        
+        }
       }
       def goAnd(l: Type, r: Type) = go(l) & (go(r), pre)
       def goOr(l: Type, r: Type) = go(l) | (go(r), pre)
@@ -603,9 +603,9 @@ object Types {
      *      and matching result types after renaming corresponding parameter types
      *      if the method types are dependent.
      *    - Or both types are =:=-equivalent
-     *    - Or phase.erasedTypes is false, and neither type takes 
+     *    - Or phase.erasedTypes is false, and neither type takes
      *      term or type parameters.
-     *      
+     *
      *  (*) when matching with a Java method, we also regard Any and Object as equivalent
      *      parameter types.
      */
@@ -777,9 +777,9 @@ object Types {
      *  to just U. Does not perform the reduction if the resulting type would contain
      *  a reference to the "this" of the current refined type. But does follow
      *  aliases in order to avoid such references. Example:
-     *  
+     *
      *      Lambda$I { type $hk$Arg0 = String, type Apply = Lambda$I{...}.$hk$Arg0 } # Apply
-     *    
+     *
      *  Here, the refinement for `Apply` has a refined this node, yet dereferencing ones more
      *  yields `String` as the result of lookupRefined.
      */
@@ -788,7 +788,7 @@ object Types {
         case pre: RefinedType =>
           if (pre.refinedName ne name) loop(pre.parent)
           else pre.refinedInfo match {
-            case TypeAlias(tp) => 
+            case TypeAlias(tp) =>
               if (!pre.refinementRefersToThis) tp
               else tp match {
                 case TypeRef(SkolemType(`pre`), alias) => lookupRefined(alias)
@@ -1158,7 +1158,7 @@ object Types {
     private[this] var lastDenotation: Denotation = _
     private[this] var lastSymbol: Symbol = _
     private[this] var checkedPeriod = Nowhere
-    
+
     // Invariants:
     // (1) checkedPeriod != Nowhere  =>  lastDenotation != null
     // (2) lastDenotation != null    =>  lastSymbol != null
@@ -1286,7 +1286,7 @@ object Types {
           checkSymAssign(denot.symbol)
 
       // additional checks that intercept `denot` can be added here
-      
+
       lastDenotation = denot
       lastSymbol = denot.symbol
     }
@@ -1737,10 +1737,10 @@ object Types {
     extends CachedProxyType with BindingType with ValueType {
 
     val refinedInfo: Type
-    
+
     private var refinementRefersToThisCache: Boolean = _
     private var refinementRefersToThisKnown: Boolean = false
-    
+
     def refinementRefersToThis(implicit ctx: Context): Boolean = {
       if (!refinementRefersToThisKnown) {
         refinementRefersToThisCache = refinedInfo.containsSkolemType(this)
@@ -1778,7 +1778,7 @@ object Types {
                && !parent.isLambda)
         derivedRefinedType(parent.EtaExpand, refinedName, refinedInfo)
       else
-        if (false) RefinedType(parent, refinedName, refinedInfo) 
+        if (false) RefinedType(parent, refinedName, refinedInfo)
         else RefinedType(parent, refinedName, rt => refinedInfo.substSkolem(this, SkolemType(rt)))
     }
 
@@ -1929,11 +1929,11 @@ object Types {
 
     def isJava = false
     def isImplicit = false
-    
+
     private val resType = resultTypeExp(this)
     assert(resType.exists)
-    
-    override def resultType(implicit ctx: Context): Type = 
+
+    override def resultType(implicit ctx: Context): Type =
       if (dependencyStatus == FalseDeps) { // dealias all false dependencies
         val dealiasMap = new TypeMap {
           def apply(tp: Type) = tp match {
@@ -1949,28 +1949,28 @@ object Types {
       else resType
 
     var myDependencyStatus: DependencyStatus = Unknown
-    
+
     private def combine(x: DependencyStatus, y: DependencyStatus): DependencyStatus = {
       val status = (x & StatusMask) max (y & StatusMask)
       val provisional = (x | y) & Provisional
       (if (status == TrueDeps) status else status | provisional).toByte
     }
-    
+
     /** The dependency status of this method. Some examples:
-     *  
+     *
      *    class C extends { type S; type T = String }
      *    def f(x: C)(y: Boolean)   // dependencyStatus = NoDeps
      *    def f(x: C)(y: x.S)       // dependencyStatus = TrueDeps
-     *    def f(x: C)(y: x.T)       // dependencyStatus = FalseDeps, i.e. 
+     *    def f(x: C)(y: x.T)       // dependencyStatus = FalseDeps, i.e.
      *                              // dependency can be eliminated by dealiasing.
      */
     private def dependencyStatus(implicit ctx: Context): DependencyStatus = {
       if (myDependencyStatus != Unknown) myDependencyStatus
       else {
         val isDepAcc = new TypeAccumulator[DependencyStatus] {
-          def apply(x: DependencyStatus, tp: Type) = 
+          def apply(x: DependencyStatus, tp: Type) =
             if (x == TrueDeps) x
-            else 
+            else
               tp match {
                 case MethodParam(`thisMethodType`, _) => TrueDeps
                 case tp @ TypeRef(MethodParam(`thisMethodType`, _), name) =>
@@ -1992,7 +1992,7 @@ object Types {
      *  which cannot be eliminated by de-aliasing?
      */
     def isDependent(implicit ctx: Context): Boolean = dependencyStatus == TrueDeps
-    
+
     protected def computeSignature(implicit ctx: Context): Signature =
       resultSignature.prepend(paramTypes, isJava)
 
@@ -2071,7 +2071,7 @@ object Types {
   object MethodType extends MethodTypeCompanion {
     def apply(paramNames: List[TermName], paramTypes: List[Type])(resultTypeExp: MethodType => Type)(implicit ctx: Context) =
       unique(new CachedMethodType(paramNames, paramTypes)(resultTypeExp))
-      
+
     private type DependencyStatus = Byte
     private final val Unknown: DependencyStatus = 0   // not yet computed
     private final val NoDeps: DependencyStatus = 1    // no dependent parameters found
@@ -2116,7 +2116,7 @@ object Types {
 
     val paramBounds = paramBoundsExp(this)
     val resType = resultTypeExp(this)
-    
+
     override def resultType(implicit ctx: Context) = resType
 
     protected def computeSignature(implicit ctx: Context) = resultSignature
@@ -2234,7 +2234,7 @@ object Types {
     type BT = Type
     override def underlying(implicit ctx: Context) = binder
     def copyBoundType(bt: BT) = SkolemType(bt)
-    
+
     // need to customize hashCode and equals to prevent infinite recursion for
     // refinements that refer to the refinement type via this
     override def computeHash = addDelta(binder.identityHash, 41)
@@ -2263,7 +2263,7 @@ object Types {
    *  @param  owningTree    The function part of the TypeApply tree tree that introduces
    *                        the type variable.
    *  @paran  owner         The current owner if the context where the variable was created.
-   *  
+   *
    *  `owningTree` and `owner` are used to determine whether a type-variable can be instantiated
    *  at some given point. See `Inferencing#interpolateUndetVars`.
    */
@@ -2599,7 +2599,7 @@ object Types {
       if ((annot eq this.annot) && (tpe eq this.tpe)) this
       else AnnotatedType(annot, tpe)
 
-    override def stripTypeVar(implicit ctx: Context): Type = 
+    override def stripTypeVar(implicit ctx: Context): Type =
       derivedAnnotatedType(annot, tpe.stripTypeVar)
     override def stripAnnots(implicit ctx: Context): Type = tpe.stripAnnots
   }
@@ -2871,7 +2871,7 @@ object Types {
     protected def applyToAnnot(x: T, annot: Annotation): T = x // don't go into annotations
 
     protected var variance = 1
-    
+
     protected def applyToPrefix(x: T, tp: NamedType) = {
       val saved = variance
       variance = 0
@@ -2879,7 +2879,7 @@ object Types {
       variance = saved
       result
     }
-    
+
     def foldOver(x: T, tp: Type): T = tp match {
       case tp: TypeRef =>
         if (stopAtStatic && tp.symbol.isStatic) x
@@ -3073,7 +3073,7 @@ object Types {
   // ----- Debug ---------------------------------------------------------
 
   var debugTrace = false
-  
+
   val watchList = List[String](
   ) map (_.toTypeName)
 
diff --git a/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala b/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala
index 52ea7ba38..935c94055 100644
--- a/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala
+++ b/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala
@@ -139,7 +139,7 @@ class ClassfileParser(
     if (companionClassMethod.exists) companionClassMethod.entered
     val companionModuleMethod = ctx.synthesizeCompanionMethod(nme.COMPANION_MODULE_METHOD, moduleRoot, classRoot)
     if (companionModuleMethod.exists) companionModuleMethod.entered
-    
+
     setClassInfo(classRoot, classInfo)
     setClassInfo(moduleRoot, staticInfo)
   }
@@ -590,7 +590,7 @@ class ClassfileParser(
         val targs = tparams.map(_.typeRef)
         val paramNames = attrs.map(_.name.asTermName)
         val paramTypes = attrs.map(_.info.resultType)
-        
+
         def addConstr(ptypes: List[Type]) = {
           val mtype = MethodType(paramNames, ptypes, classRoot.typeRef.appliedTo(targs))
           val constrType = if (tparams.isEmpty) mtype else TempPolyType(tparams, mtype)
@@ -606,15 +606,15 @@ class ClassfileParser(
               addDefaultGetter(attr, i)
             }
         }
-        
+
         addConstr(paramTypes)
         if (paramTypes.nonEmpty)
           paramTypes.last match {
-            case defn.ArrayType(elemtp) => 
-              addConstr(paramTypes.init :+ defn.RepeatedParamType.appliedTo(elemtp))        
+            case defn.ArrayType(elemtp) =>
+              addConstr(paramTypes.init :+ defn.RepeatedParamType.appliedTo(elemtp))
             case _ =>
         }
-          
+
     }
   }
 
diff --git a/src/dotty/tools/dotc/core/pickling/DottyUnpickler.scala b/src/dotty/tools/dotc/core/pickling/DottyUnpickler.scala
index 84a9a1744..64be68975 100644
--- a/src/dotty/tools/dotc/core/pickling/DottyUnpickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/DottyUnpickler.scala
@@ -23,14 +23,14 @@ class DottyUnpickler(bytes: Array[Byte]) {
 
   private val unpickler = new TastyUnpickler(bytes)
   private val treeUnpickler = unpickler.unpickle(new TreeSectionUnpickler).get
-  
+
   /** Enter all toplevel classes and objects into their scopes
    *  @param roots          a set of SymDenotations that should be overwritten by unpickling
    */
-  def enter(roots: Set[SymDenotation])(implicit ctx: Context): Unit = 
+  def enter(roots: Set[SymDenotation])(implicit ctx: Context): Unit =
     treeUnpickler.enterTopLevel(roots)
-  
-  /** The unpickled trees 
+
+  /** The unpickled trees
    *  @param readPositions if true, trees get decorated with position information.
    */
   def body(readPositions: Boolean = false)(implicit ctx: Context): List[Tree] = {
@@ -44,7 +44,7 @@ class DottyUnpickler(bytes: Array[Byte]) {
     def unpickle(reader: TastyReader, tastyName: TastyName.Table) =
       new TreeUnpickler(reader, tastyName)
   }
-  
+
   private class PositionsSectionUnpickler extends SectionUnpickler[(Position, AddrToPosition)]("Positions") {
     def unpickle(reader: TastyReader, tastyName: TastyName.Table) =
       new PositionUnpickler(reader).unpickle()
diff --git a/src/dotty/tools/dotc/core/pickling/NameBuffer.scala b/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
index a60767fe6..2a6239c5a 100644
--- a/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
+++ b/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
@@ -24,14 +24,14 @@ class NameBuffer extends TastyBuffer(100000) {
       ref
   }
   def nameIndex(name: Name): NameRef = {
-    val tname = 
+    val tname =
       if (name.isShadowedName) Shadowed(nameIndex(name.revertShadowed))
       else Simple(name.toTermName)
     nameIndex(tname)
   }
-  
+
   def nameIndex(str: String): NameRef = nameIndex(str.toTermName)
-  
+
   def fullNameIndex(name: Name): NameRef = {
     val pos = name.lastIndexOf('.')
     if (pos > 0)
@@ -39,7 +39,7 @@ class NameBuffer extends TastyBuffer(100000) {
     else
       nameIndex(name)
   }
-  
+
   private def withLength(op: => Unit): Unit = {
     val lengthAddr = currentAddr
     writeByte(0)
@@ -48,12 +48,12 @@ class NameBuffer extends TastyBuffer(100000) {
     assert(length < 128)
     putNat(lengthAddr, length, 1)
   }
-  
+
   def writeNameRef(ref: NameRef) = writeNat(ref.index)
-  
+
   def pickleName(name: TastyName): Unit = name match {
-    case Simple(name) => 
-      val bytes = 
+    case Simple(name) =>
+      val bytes =
         if (name.length == 0) new Array[Byte](0)
         else Codec.toUTF8(chrs, name.start, name.length)
       writeByte(UTF8)
@@ -62,7 +62,7 @@ class NameBuffer extends TastyBuffer(100000) {
     case Qualified(qualified, selector) =>
       writeByte(QUALIFIED)
       withLength { writeNameRef(qualified); writeNameRef(selector) }
-    case Signed(original, params, result) => 
+    case Signed(original, params, result) =>
       writeByte(SIGNED)
       withLength { writeNameRef(original); writeNameRef(result); params.foreach(writeNameRef) }
     case Expanded(prefix, original) =>
@@ -81,7 +81,7 @@ class NameBuffer extends TastyBuffer(100000) {
       writeByte(SHADOWED)
       withLength { writeNameRef(original) }
   }
-  
+
   override def assemble(): Unit = {
     var i = 0
     for ((name, ref) <- nameRefs) {
diff --git a/src/dotty/tools/dotc/core/pickling/PositionPickler.scala b/src/dotty/tools/dotc/core/pickling/PositionPickler.scala
index d791e37d2..e8a0b3d01 100644
--- a/src/dotty/tools/dotc/core/pickling/PositionPickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/PositionPickler.scala
@@ -13,13 +13,13 @@ import TastyBuffer._
 import util.Positions._
 
 object PositionPickler {
-  
+
   trait DeferredPosition {
     var parentPos: Position = NoPosition
   }
 
-  def traverse(x: Any, parentPos: Position, op: (Tree, Position) => Unit)(implicit ctx: Context): Unit = 
-    if (parentPos.exists) 
+  def traverse(x: Any, parentPos: Position, op: (Tree, Position) => Unit)(implicit ctx: Context): Unit =
+    if (parentPos.exists)
       x match {
         case x: Tree @unchecked =>
           op(x, parentPos)
@@ -33,7 +33,7 @@ object PositionPickler {
         case xs: TraversableOnce[_] =>
           xs.foreach(traverse(_, parentPos, op))
         case _ =>
-      }  
+      }
 }
 import PositionPickler._
 
@@ -41,18 +41,18 @@ class PositionPickler(pickler: TastyPickler, addrOfTree: Tree => Option[Addr]) {
   val buf = new TastyBuffer(100000)
   pickler.newSection("Positions", buf)
   import buf._
-    
+
   def picklePositions(roots: List[Tree], totalRange: Position)(implicit ctx: Context) = {
     var lastIndex = 0
     def record(tree: Tree, parentPos: Position): Unit =
       if (tree.pos.exists) {
         def msg = s"failure to pickle $tree at ${tree.pos}, parent = $parentPos"
-        val endPos = tree.pos.end min parentPos.end 
+        val endPos = tree.pos.end min parentPos.end
           // end positions can be larger than their parents
           // e.g. in the case of synthetic empty ranges, which are placed at the next token after
           // the current construct.
         val endDelta = endPos - parentPos.end
-        val startPos = 
+        val startPos =
           if (endDelta == 0) tree.pos.start max parentPos.start else tree.pos.start min endPos
           // Since end positions are corrected above, start positions have to follow suit.
         val startDelta = startPos - parentPos.start
@@ -68,7 +68,7 @@ class PositionPickler(pickler: TastyPickler, addrOfTree: Tree => Option[Addr]) {
               assert(startDelta >= 0, msg)
           }
       }
-    
+
     buf.writeNat(totalRange.end)
     traverse(roots, totalRange, record)
   }
diff --git a/src/dotty/tools/dotc/core/pickling/PositionUnpickler.scala b/src/dotty/tools/dotc/core/pickling/PositionUnpickler.scala
index 782e871c0..cfcc4a835 100644
--- a/src/dotty/tools/dotc/core/pickling/PositionUnpickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/PositionUnpickler.scala
@@ -24,11 +24,11 @@ class PositionUnpickler(reader: TastyReader) {
     while (!isAtEnd) {
       val delta1 = readDelta()
       val delta2 = readDelta()
-      val (startDelta, endDelta, indexDelta) = 
+      val (startDelta, endDelta, indexDelta) =
         if (delta2 <= 0) (delta1, -delta2, readDelta())
         else if (delta1 < 0) (0, -delta1, delta2)
         else (delta1, 0, delta2)
-      positions(curIndex) = Position(startDelta, endDelta, startDelta) 
+      positions(curIndex) = Position(startDelta, endDelta, startDelta)
         // make non-synthetic position; will be made synthetic by normalization.
       curIndex += indexDelta
     }
diff --git a/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala b/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala
index 9197a2acc..99ae331d0 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala
@@ -6,19 +6,19 @@ package pickling
 import util.Util.dble
 
 object TastyBuffer {
-  
+
   /** The number of digits of the natural number `nat`, written in base 128 format. */
-  def natSize(nat: Int): Int = 
+  def natSize(nat: Int): Int =
     if (nat < 128) 1 else natSize(nat >>> 7) + 1
 
   /** An address pointing to an index in a Tasty buffer's byte array */
   case class Addr(val index: Int) extends AnyVal {
     def -(delta: Int): Addr = Addr(this.index - delta)
     def +(delta: Int): Addr = Addr(this.index + delta)
-    
+
     def relativeTo(base: Addr): Addr = this - base.index - AddrWidth
   }
-  
+
   val NoAddr = Addr(-1)
 
   /** The maximal number of address bytes.
@@ -33,13 +33,13 @@ import TastyBuffer._
  *  and that supports reading and patching addresses represented as natural numbers.
  */
 class TastyBuffer(initialSize: Int) {
-  
+
   /** The current byte array, will be expanded as needed */
   var bytes = new Array[Byte](initialSize)
-  
+
   /** The number of bytes written */
   var length = 0
-  
+
   // -- Output routines --------------------------------------------
 
   /** Write a byte of data. */
@@ -48,7 +48,7 @@ class TastyBuffer(initialSize: Int) {
     bytes(length) = b.toByte
     length += 1
   }
-  
+
   /** Write the first `n` bytes of `data`. */
   def writeBytes(data: Array[Byte], n: Int): Unit = {
     while (bytes.length < length + n) bytes = dble(bytes)
@@ -61,13 +61,13 @@ class TastyBuffer(initialSize: Int) {
    */
   def writeNat(x: Int): Unit =
     writeLongNat(x.toLong & 0x00000000FFFFFFFFL)
-    
+
   /** Write a natural number in 2's complement big endian format, base 128.
    *  All but the last digits have bit 0x80 set.
    */
-  def writeInt(x: Int): Unit = 
+  def writeInt(x: Int): Unit =
     writeLongInt(x)
-    
+
   /**
    * Like writeNat, but for longs. Note that the
    * binary representation of LongNat is identical to Nat
@@ -84,7 +84,7 @@ class TastyBuffer(initialSize: Int) {
     if (y != 0L) writePrefix(y)
     writeByte(((x & 0x7f) | 0x80).toInt)
   }
-  
+
   /** Like writeInt, but for longs */
   def writeLongInt(x: Long): Unit = {
     def writePrefix(x: Long): Unit = {
@@ -94,22 +94,22 @@ class TastyBuffer(initialSize: Int) {
     }
     val y = x >> 7
     if (y != 0L - ((x >> 6) & 1)) writePrefix(y)
-    writeByte(((x & 0x7f) | 0x80).toInt)    
+    writeByte(((x & 0x7f) | 0x80).toInt)
   }
-  
+
   /** Write an uncompressed Long stored in 8 bytes in big endian format */
   def writeUncompressedLong(x: Long): Unit = {
     var y = x
     val bytes = new Array[Byte](8)
     for (i <- 7 to 0 by -1) {
       bytes(i) = (y & 0xff).toByte
-      y = y >>> 8      
+      y = y >>> 8
     }
     writeBytes(bytes, 8)
   }
 
   // -- Address handling --------------------------------------------
-  
+
   /** Write natural number `x` right-adjusted in a field of `width` bytes
    *  starting with address `at`.
    */
@@ -125,10 +125,10 @@ class TastyBuffer(initialSize: Int) {
     }
     assert(y == 0, s"number $x too large to fit in $width bytes")
   }
-  
+
   /** The byte at given address */
   def getByte(at: Addr): Int = bytes(at.index)
-  
+
   /** The natural number at address `at` */
   def getNat(at: Addr): Int = getLongNat(at).toInt
 
@@ -148,8 +148,8 @@ class TastyBuffer(initialSize: Int) {
   /** The address (represented as a natural number) at address `at` */
   def getAddr(at: 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 = 
+  /** The smallest address equal to or following `at` which points to a non-zero byte */
+  final def skipZeroes(at: Addr): Addr =
     if (getByte(at) != 0) at else skipZeroes(at + 1)
 
   /** The address after the natural number found at address `at`. */
@@ -160,21 +160,21 @@ class TastyBuffer(initialSize: Int) {
 
   /** The address referring to the end of data written so far */
   def currentAddr: Addr = Addr(length)
-  
+
   /** Reserve `AddrWidth` bytes to write an address into */
   def reserveAddr(): Addr = {
     val result = currentAddr
     length += AddrWidth
     result
   }
-    
+
   /** Fill reserved space at address `at` with address `target` */
-  def fillAddr(at: Addr, target: Addr) = 
+  def fillAddr(at: Addr, target: Addr) =
     putNat(at, target.index, AddrWidth)
-    
+
   /** Write address without leading zeroes */
   def writeAddr(addr: Addr): Unit = writeNat(addr.index)
-      
+
   // -- Finalization --------------------------------------------
 
   /** Hook to be overridden in subclasses.
diff --git a/src/dotty/tools/dotc/core/pickling/TastyName.scala b/src/dotty/tools/dotc/core/pickling/TastyName.scala
index e8f30a234..e47ff9fc4 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyName.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyName.scala
@@ -9,22 +9,22 @@ import collection.mutable
 abstract class TastyName
 
 object TastyName {
-  
+
   case class NameRef(val index: Int) extends AnyVal
-  
+
   case class Simple(name: TermName) extends TastyName
   case class Qualified(qualified: NameRef, selector: NameRef) extends TastyName
-  case class Signed(original: NameRef, params: List[NameRef], result: NameRef) extends TastyName 
+  case class Signed(original: NameRef, params: List[NameRef], result: NameRef) extends TastyName
   case class Expanded(prefix: NameRef, original: NameRef) extends TastyName
   case class ModuleClass(module: NameRef) extends TastyName
   case class SuperAccessor(accessed: NameRef) extends TastyName
   case class DefaultGetter(method: NameRef, num: Int) extends TastyName
   case class Shadowed(original: NameRef) extends TastyName
-  
+
   class Table extends (NameRef => TastyName) {
     private val names = new mutable.ArrayBuffer[TastyName]
     def add(name: TastyName) = names += name
     def apply(ref: NameRef) = names(ref.index)
     def contents: Iterable[TastyName] = names
   }
-}  
+}
diff --git a/src/dotty/tools/dotc/core/pickling/TastyPickler.scala b/src/dotty/tools/dotc/core/pickling/TastyPickler.scala
index f998cf377..6bd6f1c44 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyPickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyPickler.scala
@@ -9,9 +9,9 @@ import TastyBuffer._
 import java.util.UUID
 
 class TastyPickler {
-      
+
   private val sections = new mutable.ArrayBuffer[(TastyName.NameRef, TastyBuffer)]
-  
+
   private val headerBuffer = {
     val buf = new TastyBuffer(24)
     for (ch <- header) buf.writeByte(ch.toByte)
@@ -24,17 +24,17 @@ class TastyPickler {
   }
 
   val nameBuffer = new NameBuffer
-  
-  def newSection(name: String, buf: TastyBuffer) = 
+
+  def newSection(name: String, buf: TastyBuffer) =
     sections += ((nameBuffer.nameIndex(name), buf))
-  
+
   def assembleParts(): Array[Byte] = {
     def lengthWithLength(buf: TastyBuffer) = {
       buf.assemble()
       buf.length + natSize(buf.length)
     }
-    val totalSize = 
-      headerBuffer.length + 
+    val totalSize =
+      headerBuffer.length +
       lengthWithLength(nameBuffer) + {
         for ((nameRef, buf) <- sections) yield
           natSize(nameRef.index) + lengthWithLength(buf)
diff --git a/src/dotty/tools/dotc/core/pickling/TastyPrinter.scala b/src/dotty/tools/dotc/core/pickling/TastyPrinter.scala
index 37a1e3b40..9d07fc5da 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyPrinter.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyPrinter.scala
@@ -12,14 +12,14 @@ import util.Positions.{Position, offsetToInt}
 import collection.mutable
 
 class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
-  
+
   val unpickler = new TastyUnpickler(bytes)
   import unpickler.{tastyName, unpickle}
-  
+
   def nameToString(name: TastyName): String = name match {
     case Simple(name) => name.toString
     case Qualified(qual, name) => nameRefToString(qual) + "." + nameRefToString(name)
-    case Signed(original, params, result) => 
+    case Signed(original, params, result) =>
       i"${nameRefToString(original)}@${params.map(nameRefToString)}%,%:${nameRefToString(result)}"
     case Expanded(prefix, original) => s"$prefix${nme.EXPAND_SEPARATOR}$original"
     case ModuleClass(original) => nameRefToString(original) + "/MODULECLASS"
@@ -27,13 +27,13 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
     case DefaultGetter(meth, num) => nameRefToString(meth) + "/DEFAULTGETTER" + num
     case Shadowed(original) => nameRefToString(original) + "/SHADOWED"
   }
-      
+
   def nameRefToString(ref: NameRef): String = nameToString(tastyName(ref))
-  
-  def printNames() = 
+
+  def printNames() =
     for ((name, idx) <- tastyName.contents.zipWithIndex)
       println(f"$idx%4d: " + nameToString(name))
-  
+
   def printContents(): Unit = {
     println("Names:")
     printNames()
@@ -41,7 +41,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
     unpickle(new TreeSectionUnpickler)
     unpickle(new PositionSectionUnpickler)
   }
-  
+
   class TreeSectionUnpickler extends SectionUnpickler[Unit]("ASTs") {
     import PickleFormat._
     def unpickle(reader: TastyReader, tastyName: TastyName.Table): Unit = {
@@ -66,12 +66,12 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
           tag match {
             case RENAMED =>
               printName(); printName()
-            case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | NAMEDARG | BIND => 
+            case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | NAMEDARG | BIND =>
               printName(); printTrees()
             case REFINEDtype =>
               printTree(); printName(); printTrees()
             case RETURN =>
-              printNat(); printTrees() 
+              printNat(); printTrees()
             case METHODtype | POLYtype =>
               printTree()
               until(end) { printName(); printTree() }
@@ -85,16 +85,16 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
             goto(end)
           }
         }
-        else if (tag >= firstNatASTTreeTag) { 
+        else if (tag >= firstNatASTTreeTag) {
           tag match {
             case IDENT | SELECT | TERMREF | TYPEREF | SELFDEF => printName()
-            case _ => printNat() 
+            case _ => printNat()
           }
           printTree()
         }
-        else if (tag >= firstASTTreeTag) 
+        else if (tag >= firstASTTreeTag)
           printTree()
-        else if (tag >= firstNatTreeTag) 
+        else if (tag >= firstNatTreeTag)
           tag match {
             case TERMREFpkg | TYPEREFpkg | STRINGconst | IMPORTED => printName()
             case _ => printNat()
diff --git a/src/dotty/tools/dotc/core/pickling/TastyReader.scala b/src/dotty/tools/dotc/core/pickling/TastyReader.scala
index 0385e9adb..35724e557 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyReader.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyReader.scala
@@ -10,49 +10,49 @@ import collection.mutable
 
 /** A byte array buffer that can be filled with bytes or natural numbers in TASTY format,
  *  and that supports reading and patching addresses represented as natural numbers.
- *  
+ *
  *  @param bytes    The array containing data
  *  @param from     The position from which to read
  *  @param end      The position one greater than the last byte to be read
- *  @param base     The index referenced by the logical zero address Addr(0) 
+ *  @param base     The index referenced by the logical zero address Addr(0)
  */
 class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int = 0) {
-  
+
   def this(bytes: Array[Byte]) = this(bytes, 0, bytes.length)
-  
+
   private var bp: Int = start
-  
+
   def addr(idx: Int) = Addr(idx - base)
   def index(addr: Addr) = addr.index + base
-  
+
   /** The address of the first byte to read, respectively byte that was read */
   def startAddr: Addr = addr(start)
-  
+
   /** The address of the next byte to read */
   def currentAddr: Addr = addr(bp)
-  
+
   /** the address one greater than the last brte to read */
   def endAddr: Addr = addr(end)
-    
+
   /** Have all bytes been read? */
   def isAtEnd: Boolean = bp == end
-  
+
   /** A new reader over the same array with the same address base, but with
    *  specified start and end positions
    */
-  def subReader(start: Addr, end: Addr): TastyReader = 
+  def subReader(start: Addr, end: Addr): TastyReader =
     new TastyReader(bytes, index(start), index(end), base)
-  
+
   /** Read a byte of data. */
   def readByte(): Int = {
     val result = bytes(bp) & 0xff
     bp += 1
     result
   }
-  
-  /** Returns the next byte of data as a natural number without advancing the read position */  
+
+  /** Returns the next byte of data as a natural number without advancing the read position */
   def nextByte: Int = bytes(bp) & 0xff
-  
+
   /** Read the next `n` bytes of `data`. */
   def readBytes(n: Int): Array[Byte] = {
     val result = new Array[Byte](n)
@@ -65,12 +65,12 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
    *  All but the last digits have bit 0x80 set.
    */
   def readNat(): Int = readLongNat.toInt
-  
+
   /** Read an integer number in 2's complement big endian format, base 128.
    *  All but the last digits have bit 0x80 set.
    */
   def readInt(): Int = readLongInt.toInt
-    
+
   /** Read a natural number fitting in a Long in big endian format, base 128.
    *  All but the last digits have bit 0x80 set.
    */
@@ -84,7 +84,7 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
     } while ((b & 0x80) == 0)
     x
   }
-  
+
   /** Read a long integer number in 2's complement big endian format, base 128. */
   def readLongInt(): Long = {
     var b = bytes(bp)
@@ -95,9 +95,9 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
       x = (x << 7) | (b & 0x7f)
       bp += 1
     }
-    x    
+    x
   }
-  
+
   /** Read an uncompressed Long stored in 8 bytes in big endian format */
   def readUncompressedLong(): Long = {
     var x = 0
@@ -105,22 +105,22 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
       x = (x << 8) | (readByte() & 0xff)
     x
   }
-  
+
   /** Read a natural number and return as a NameRef */
   def readNameRef() = NameRef(readNat())
-  
-  /** Read a natural number and return as an address */  
+
+  /** Read a natural number and return as an address */
   def readAddr() = Addr(readNat())
-  
+
   /** Read a length number and return the absolute end address implied by it,
    *  given as <address following length field> + <length-value-read>.
    */
   def readEnd(): Addr = addr(readNat() + bp)
-  
+
   /** Set read position to the one pointed to by `addr` */
-  def goto(addr: Addr): Unit = 
+  def goto(addr: Addr): Unit =
     bp = index(addr)
- 
+
   /** Perform `op` until `end` address is reached and collect results in a list. */
   def until[T](end: Addr)(op: => T): List[T] = {
     val buf = new mutable.ListBuffer[T]
diff --git a/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala b/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala
index b5e978afa..5fbb85768 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala
@@ -7,9 +7,9 @@ import PickleFormat._
 import Names.{Name, termName}
 import java.util.UUID
 
-object TastyUnpickler {  
+object TastyUnpickler {
   class UnpickleException(msg: String) extends Exception(msg)
-  
+
   abstract class SectionUnpickler[R](val name: String) {
     def unpickle(reader: TastyReader, tastyName: TastyName.Table): R
   }
@@ -19,28 +19,28 @@ import TastyUnpickler._
 
 class TastyUnpickler(reader: TastyReader) {
   import reader._
-    
+
   def this(bytes: Array[Byte]) = this(new TastyReader(bytes))
-  
+
   private val sectionReader = new mutable.HashMap[String, TastyReader]
   val tastyName = new TastyName.Table
-  
-  def check(cond: Boolean, msg: => String) = 
+
+  def check(cond: Boolean, msg: => String) =
     if (!cond) throw new UnpickleException(msg)
-  
+
   def readString(): String = {
     val TastyName.Simple(name) = tastyName(readNameRef())
     name.toString
   }
-    
+
   def readName(): TastyName = {
     import TastyName._
-    val tag = readByte() 
+    val tag = readByte()
     val length = readNat()
     val start = currentAddr
     val end = start + length
     val result = tag match {
-      case UTF8 => 
+      case UTF8 =>
         goto(end)
         Simple(termName(bytes, start.index, length))
       case QUALIFIED =>
@@ -64,21 +64,21 @@ class TastyUnpickler(reader: TastyReader) {
     assert(currentAddr == end, s"bad name $result $start $currentAddr $end")
     result
   }
-  
+
   private def readHeader(): UUID = {
     for (i <- 0 until header.length)
       check(readByte() == header(i), "not a TASTy file")
     val major = readNat()
     val minor = readNat()
-    check(major == MajorVersion && minor <= MinorVersion, 
+    check(major == MajorVersion && minor <= MinorVersion,
       s"""TASTy signature has wrong version.
          | expected: $MajorVersion.$MinorVersion
          | found   : $major.$minor""".stripMargin)
     new UUID(readUncompressedLong(), readUncompressedLong())
   }
-  
+
   val uuid = readHeader()
-  
+
   locally {
     until(readEnd()) { tastyName.add(readName()) }
     while (!isAtEnd) {
@@ -88,8 +88,8 @@ class TastyUnpickler(reader: TastyReader) {
       goto(secEnd)
     }
   }
-  
-  def unpickle[R](sec: SectionUnpickler[R]): Option[R] = 
+
+  def unpickle[R](sec: SectionUnpickler[R]): Option[R] =
     for (reader <- sectionReader.get(sec.name)) yield
       sec.unpickle(reader, tastyName)
 }
diff --git a/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala b/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala
index c1eae5014..c224fc30b 100644
--- a/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala
@@ -11,20 +11,20 @@ import ast.tpd.Tree
 class TreeBuffer extends TastyBuffer(1000000) {
 
   private final val ItemsOverOffsets = 2
-    
+
   private val initialOffsetSize = bytes.length / (AddrWidth * ItemsOverOffsets)
   private var offsets = new Array[Int](initialOffsetSize)
   private var isRelative = new Array[Boolean](initialOffsetSize)
   private var delta: Array[Int] = _
   private var numOffsets = 0
 
-  private[pickling] val pickledTrees = new java.util.IdentityHashMap[Tree, Any] // Value type is really Addr, but that's not compatible with null  
-  
+  private[pickling] val pickledTrees = new java.util.IdentityHashMap[Tree, Any] // Value type is really Addr, but that's not compatible with null
+
   def addrOfTree(tree: Tree): Option[Addr] = pickledTrees.get(tree) match {
     case null => None
     case n => Some(n.asInstanceOf[Addr])
   }
-            
+
   private def offset(i: Int): Addr = Addr(offsets(i))
 
   private def keepOffset(relative: Boolean): Unit = {
@@ -36,7 +36,7 @@ class TreeBuffer extends TastyBuffer(1000000) {
     isRelative(numOffsets) = relative
     numOffsets += 1
   }
-       
+
   /** Reserve space for a reference, to be adjusted later */
   def reserveRef(relative: Boolean): Addr = {
     val addr = currentAddr
@@ -50,19 +50,19 @@ class TreeBuffer extends TastyBuffer(1000000) {
     keepOffset(relative = false)
     fillAddr(reserveAddr(), target)
   }
-  
+
   /** Fill previously reserved field with a reference */
   def fillRef(at: Addr, target: Addr, relative: Boolean) = {
     val addr = if (relative) target.relativeTo(at) else target
     fillAddr(at, addr)
   }
-  
+
   /** The amount by which the bytes at the given address are shifted under compression */
   def deltaAt(at: Addr): Int = {
     val idx = bestFit(offsets, numOffsets, at.index - 1)
     if (idx < 0) 0 else delta(idx)
   }
-    
+
   /** The address to which `x` is translated under compression */
   def adjusted(x: Addr): Addr = x - deltaAt(x)
 
@@ -77,11 +77,11 @@ class TreeBuffer extends TastyBuffer(1000000) {
       val skippedCount = skippedOff.index - off.index
       assert(skippedCount < AddrWidth, s"unset field at position $off")
       lastDelta += skippedCount
-      delta(i) = lastDelta 
+      delta(i) = lastDelta
       i += 1
     }
   }
-  
+
   /** The absolute or relative adjusted address at index `i` of `offsets` array*/
   private def adjustedOffset(i: Int): Addr = {
     val at = offset(i)
@@ -90,12 +90,12 @@ class TreeBuffer extends TastyBuffer(1000000) {
       val start = skipNat(at)
       val len1 = original + delta(i) - deltaAt(original + start.index)
       val len2 = adjusted(original + start.index) - adjusted(start).index
-      assert(len1 == len2, 
+      assert(len1 == len2,
           s"adjusting offset #$i: $at, original = $original, len1 = $len1, len2 = $len2")
       len1
     } else adjusted(original)
   }
-  
+
   /** Adjust all offsets according to previously computed deltas */
   private def adjustOffsets(): Unit = {
     for (i <- 0 until numOffsets) {
@@ -103,7 +103,7 @@ class TreeBuffer extends TastyBuffer(1000000) {
       fillAddr(offset(i), corrected)
     }
   }
-    
+
   /** Adjust deltas to also take account references that will shrink (and thereby
    *  generate additional zeroes that can be skipped) due to previously
    *  computed adjustements.
@@ -118,13 +118,13 @@ class TreeBuffer extends TastyBuffer(1000000) {
       delta1(i) = lastDelta
       i += 1
     }
-    val saved = 
+    val saved =
       if (numOffsets == 0) 0
       else delta1(numOffsets - 1) - delta(numOffsets - 1)
     delta = delta1
     saved
   }
-   
+
   /** Compress pickle buffer, shifting bytes to close all skipped zeroes. */
   private def compress(): Int = {
     var lastDelta = 0
@@ -147,7 +147,7 @@ class TreeBuffer extends TastyBuffer(1000000) {
     length -= lastDelta
     wasted
   }
-  
+
   def adjustPickledTrees(): Unit = {
     val it = pickledTrees.keySet.iterator
     while (it.hasNext) {
@@ -155,7 +155,7 @@ class TreeBuffer extends TastyBuffer(1000000) {
       pickledTrees.put(tree, adjusted(pickledTrees.get(tree).asInstanceOf[Addr]))
     }
   }
-  
+
   /** Final assembly, involving the following steps:
    *   - compute deltas
    *   - adjust deltas until additional savings are < 1% of total
diff --git a/src/dotty/tools/dotc/core/pickling/TreePickler.scala b/src/dotty/tools/dotc/core/pickling/TreePickler.scala
index 85addc563..53dd34094 100644
--- a/src/dotty/tools/dotc/core/pickling/TreePickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreePickler.scala
@@ -33,7 +33,7 @@ class TreePickler(pickler: TastyPickler) {
   }
 
   def preRegister(tree: Tree)(implicit ctx: Context): Unit = tree match {
-    case tree: MemberDef => 
+    case tree: MemberDef =>
       if (!symRefs.contains(tree.symbol)) symRefs(tree.symbol) = NoAddr
     case _ =>
   }
@@ -54,13 +54,13 @@ class TreePickler(pickler: TastyPickler) {
     val Signature(params, result) = sig
     pickleName(TastyName.Signed(nameIndex(name), params.map(fullNameIndex), fullNameIndex(result)))
   }
-  
+
   private def pickleName(sym: Symbol)(implicit ctx: Context): Unit =
-    if (sym is Flags.ExpandedName) 
+    if (sym is Flags.ExpandedName)
       pickleName(TastyName.Expanded(
         nameIndex(sym.name.expandedPrefix), nameIndex(sym.name.unexpandedName)))
     else pickleName(sym.name)
-      
+
   private def pickleSymRef(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match {
     case Some(label) =>
       if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym)
@@ -68,20 +68,20 @@ class TreePickler(pickler: TastyPickler) {
       ctx.log(i"pickling reference to as yet undefined $sym in ${sym.owner}", sym.pos)
       pickleForwardSymRef(sym)
   }
-  
+
   private def pickleForwardSymRef(sym: Symbol)(implicit ctx: Context) = {
     val ref = reserveRef(relative = false)
     assert(!sym.is(Flags.Package), sym)
-    forwardSymRefs(sym) = ref :: forwardSymRefs.getOrElse(sym, Nil)  
+    forwardSymRefs(sym) = ref :: forwardSymRefs.getOrElse(sym, Nil)
   }
-  
+
   private def isLocallyDefined(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match {
     case Some(label) => assert(sym.exists); label != NoAddr
     case None => false
   }
 
   def pickle(trees: List[Tree])(implicit ctx: Context) = {
-    
+
     def qualifiedName(sym: Symbol): TastyName =
       if (sym.isRoot || sym.owner.isRoot) TastyName.Simple(sym.name.toTermName)
       else TastyName.Qualified(nameIndex(qualifiedName(sym.owner)), nameIndex(sym.name))
@@ -141,9 +141,9 @@ class TreePickler(pickler: TastyPickler) {
         println(i"error when pickling type $tpe0")
         throw ex
     }
-      
+
     def pickleNewType(tpe: Type, richTypes: Boolean): Unit = try { tpe match {
-      case ConstantType(value) => 
+      case ConstantType(value) =>
         pickleConstant(value)
       case tpe: TypeRef if tpe.info.isAlias && tpe.symbol.is(Flags.AliasPreferred) =>
         pickleType(tpe.info.bounds.hi)
@@ -152,12 +152,12 @@ class TreePickler(pickler: TastyPickler) {
         if (sym.is(Flags.Package)) {
           writeByte(if (tpe.isType) TYPEREFpkg else TERMREFpkg)
           pickleName(qualifiedName(sym))
-        } 
+        }
         else {
           assert(tpe.prefix == NoPrefix)
           def pickleRef() = {
             writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect)
-            pickleSymRef(sym)        
+            pickleSymRef(sym)
           }
           if (sym is Flags.BindDefinedType) {
             registerDef(sym)
@@ -175,14 +175,14 @@ class TreePickler(pickler: TastyPickler) {
         pickleNameAndSig(tpe.name, tpe.signature); pickleType(tpe.prefix)
       case tpe: NamedType =>
         if (tpe.name == tpnme.Apply && tpe.prefix.argInfos.nonEmpty && tpe.prefix.isInstantiatedLambda)
-          // instantiated lambdas are pickled as APPLIEDTYPE; #Apply will 
+          // instantiated lambdas are pickled as APPLIEDTYPE; #Apply will
           // be reconstituted when unpickling.
           pickleType(tpe.prefix)
         else if (isLocallyDefined(tpe.symbol)) {
           writeByte(if (tpe.isType) TYPEREFsymbol else TERMREFsymbol)
           pickleSymRef(tpe.symbol); pickleType(tpe.prefix)
         }
-        else { 
+        else {
           writeByte(if (tpe.isType) TYPEREF else TERMREF)
           pickleName(tpe.name); pickleType(tpe.prefix)
         }
@@ -199,10 +199,10 @@ class TreePickler(pickler: TastyPickler) {
         val args = tpe.argInfos(interpolate = false)
         if (args.isEmpty) {
           writeByte(REFINEDtype)
-          withLength { 
+          withLength {
             pickleType(tpe.parent)
             pickleName(tpe.refinedName)
-            pickleType(tpe.refinedInfo, richTypes = true) 
+            pickleType(tpe.refinedInfo, richTypes = true)
           }
         }
         else {
@@ -211,8 +211,8 @@ class TreePickler(pickler: TastyPickler) {
         }
       case tpe: TypeAlias =>
         writeByte(TYPEALIAS)
-        withLength { 
-          pickleType(tpe.alias, richTypes) 
+        withLength {
+          pickleType(tpe.alias, richTypes)
           tpe.variance match {
             case 1 => writeByte(COVARIANT)
             case -1 => writeByte(CONTRAVARIANT)
@@ -237,7 +237,7 @@ class TreePickler(pickler: TastyPickler) {
       case tpe: PolyType if richTypes =>
         writeByte(POLYtype)
         pickleMethodic(tpe.resultType, tpe.paramNames, tpe.paramBounds)
-      case tpe: PolyParam => 
+      case tpe: PolyParam =>
         if (!pickleParamType(tpe))
           // TODO figure out why this case arises in e.g. pickling AbstractFileReader.
           ctx.typerState.constraint.entry(tpe) match {
@@ -249,19 +249,19 @@ class TreePickler(pickler: TastyPickler) {
       case tpe: LazyRef =>
         pickleType(tpe.ref)
     }} catch {
-      case ex: AssertionError => 
+      case ex: AssertionError =>
         println(i"error while pickling type $tpe")
         throw ex
     }
-    
-    def pickleMethodic(result: Type, names: List[Name], types: List[Type]) = 
+
+    def pickleMethodic(result: Type, names: List[Name], types: List[Type]) =
       withLength {
         pickleType(result, richTypes = true)
         (names, types).zipped.foreach { (name, tpe) =>
-          pickleName(name); pickleType(tpe)       
+          pickleName(name); pickleType(tpe)
         }
       }
-    
+
     def pickleParamType(tpe: ParamType): Boolean = {
       val binder = pickledTypes.get(tpe.binder)
       val pickled = binder != null
@@ -271,10 +271,10 @@ class TreePickler(pickler: TastyPickler) {
       }
       pickled
     }
-    
+
     def pickleTpt(tpt: Tree): Unit = pickleType(tpt.tpe) // TODO correlate with original when generating positions
-    
-    def pickleTreeUnlessEmpty(tree: Tree): Unit = 
+
+    def pickleTreeUnlessEmpty(tree: Tree): Unit =
       if (!tree.isEmpty) pickleTree(tree)
 
     def pickleTree(tree: Tree): Unit = try {
@@ -283,14 +283,14 @@ class TreePickler(pickler: TastyPickler) {
       case Ident(name) =>
         tree.tpe match {
           case tp: TermRef => pickleType(tp)
-          case _ => 
+          case _ =>
              writeByte(IDENT)
              pickleName(name)
              pickleType(tree.tpe)
         }
-      case This(_) => 
+      case This(_) =>
         pickleType(tree.tpe)
-      case Select(qual, name) => 
+      case Select(qual, name) =>
         writeByte(SELECT)
         val realName = tree.tpe match {
           case tp: NamedType if tp.name.isShadowedName => tp.name
@@ -321,7 +321,7 @@ class TreePickler(pickler: TastyPickler) {
         }
       case Super(qual, mix) =>
         writeByte(SUPER)
-        withLength { 
+        withLength {
           pickleTree(qual);
           if (!mix.isEmpty) {
             val SuperType(_, mixinType) = tree.tpe
@@ -350,12 +350,12 @@ class TreePickler(pickler: TastyPickler) {
       case If(cond, thenp, elsep) =>
         writeByte(IF)
         withLength{ pickleTree(cond); pickleTree(thenp); pickleTree(elsep) }
-      case Closure(env, meth, tpt) => 
+      case Closure(env, meth, tpt) =>
         writeByte(LAMBDA)
         assert(env.isEmpty)
-        withLength{ 
+        withLength{
           pickleTree(meth)
-          if (tpt.tpe.exists) pickleTpt(tpt) 
+          if (tpt.tpe.exists) pickleTpt(tpt)
         }
       case Match(selector, cases) =>
         writeByte(MATCH)
@@ -383,14 +383,14 @@ class TreePickler(pickler: TastyPickler) {
         withLength { alts.foreach(pickleTree) }
       case UnApply(fun, implicits, patterns) =>
         writeByte(UNAPPLY)
-        withLength { 
+        withLength {
           pickleTree(fun)
           for (implicitArg <- implicits) {
             writeByte(IMPLICITarg)
             pickleTree(implicitArg)
           }
           pickleType(tree.tpe)
-          patterns.foreach(pickleTree) 
+          patterns.foreach(pickleTree)
         }
       case tree: ValDef =>
         pickleDef(VALDEF, tree.symbol, tree.tpt, tree.rhs)
@@ -400,7 +400,7 @@ class TreePickler(pickler: TastyPickler) {
           for (vparams <- tree.vparamss) {
             writeByte(PARAMS)
             withLength { pickleParams(vparams) }
-          }          
+          }
         }
         pickleDef(DEFDEF, tree.symbol, tree.tpt, tree.rhs, pickleAllParams)
       case tree: TypeDef =>
@@ -410,7 +410,7 @@ class TreePickler(pickler: TastyPickler) {
         writeByte(TEMPLATE)
         val (params, rest) = tree.body partition {
           case stat: TypeDef => stat.symbol is Flags.Param
-          case stat: ValOrDefDef => 
+          case stat: ValOrDefDef =>
             stat.symbol.is(Flags.ParamAccessor) && !stat.symbol.isSetter
           case _ => false
         }
@@ -435,7 +435,7 @@ class TreePickler(pickler: TastyPickler) {
         withLength {
           pickleTree(expr)
           selectors foreach {
-            case Pair(Ident(from), Ident(to)) => 
+            case Pair(Ident(from), Ident(to)) =>
               writeByte(RENAMED)
               withLength { pickleName(from); pickleName(to) }
             case Ident(name) =>
@@ -468,13 +468,13 @@ class TreePickler(pickler: TastyPickler) {
         pickleModifiers(sym)
       }
     }
-    
+
     def pickleParam(tree: Tree): Unit = tree match {
       case tree: ValDef => pickleDef(PARAM, tree.symbol, tree.tpt)
       case tree: DefDef => pickleDef(PARAM, tree.symbol, tree.tpt, tree.rhs)
-      case tree: TypeDef => pickleDef(TYPEPARAM, tree.symbol, tree.rhs)      
+      case tree: TypeDef => pickleDef(TYPEPARAM, tree.symbol, tree.rhs)
     }
-    
+
     def pickleParams(trees: List[Tree]): Unit = {
       trees.foreach(preRegister)
       trees.foreach(pickleParam)
@@ -504,7 +504,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is Local) writeByte(LOCAL)
       if (flags is Synthetic) writeByte(SYNTHETIC)
       if (flags is Artifact) writeByte(ARTIFACT)
-      if (flags is Scala2x) writeByte(SCALA2X) 
+      if (flags is Scala2x) writeByte(SCALA2X)
       if (flags is InSuperCall) writeByte(INSUPERCALL)
       if (sym.isTerm) {
         if (flags is Implicit) writeByte(IMPLICIT)
@@ -512,18 +512,18 @@ class TreePickler(pickler: TastyPickler) {
         if (flags is AbsOverride) writeByte(ABSOVERRIDE)
         if (flags is Mutable) writeByte(MUTABLE)
         if (flags is Accessor) writeByte(FIELDaccessor)
-        if (flags is CaseAccessor) writeByte(CASEaccessor)  
+        if (flags is CaseAccessor) writeByte(CASEaccessor)
         if (flags is DefaultParameterized) writeByte(DEFAULTparameterized)
       } else {
         if (flags is Sealed) writeByte(SEALED)
-        if (flags is Abstract) writeByte(ABSTRACT)      
+        if (flags is Abstract) writeByte(ABSTRACT)
         if (flags is Trait) writeByte(TRAIT)
         if (flags is Covariant) writeByte(COVARIANT)
         if (flags is Contravariant) writeByte(CONTRAVARIANT)
       }
       sym.annotations.foreach(pickleAnnotation)
     }
-    
+
     def pickleAnnotation(ann: Annotation) = {
       writeByte(ANNOTATION)
       withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) }
diff --git a/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala b/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
index c177b05c0..07d3badf7 100644
--- a/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
@@ -24,7 +24,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
   import dotty.tools.dotc.core.pickling.PickleFormat._
   import TastyName._
   import tpd._
-  
+
   private var readPositions = false
   private var totalRange = NoPosition
   private var positions: collection.Map[Addr, Position] = _
@@ -40,12 +40,12 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
     this.totalRange = totalRange
     this.positions = positions
   }
-  
+
   private val symAtAddr  = new mutable.HashMap[Addr, Symbol]
   private val treeAtAddr = new mutable.HashMap[Addr, Tree]
   private val typeAtAddr = new mutable.HashMap[Addr, Type] // currently populated only for types that are known to be SHAREd.
-  private var stubs: Set[Symbol] = Set() 
-  
+  private var stubs: Set[Symbol] = Set()
+
   private var roots: Set[SymDenotation] = null
 
   /** Enter all toplevel classes and objects into their scopes
@@ -64,13 +64,13 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
     normalizePos(stats, totalRange)
     stats
   }
-    
+
   def toTermName(tname: TastyName): TermName = tname match {
     case Simple(name) => name
     case Qualified(qual, name) => toTermName(qual) ++ "." ++ toTermName(name)
     case Signed(original, params, result) => toTermName(original)
     case Shadowed(original) => toTermName(original).shadowedName
-    case Expanded(prefix, original) => toTermName(original).expandedName(toTermName(prefix)) 
+    case Expanded(prefix, original) => toTermName(original).expandedName(toTermName(prefix))
     case ModuleClass(original) => toTermName(original).moduleClassName.toTermName
     case SuperAccessor(accessed) => ???
     case DefaultGetter(meth, num) => ???
@@ -88,17 +88,17 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
 
   class TreeReader(val reader: TastyReader) {
     import reader._
-        
+
     def forkAt(start: Addr) = new TreeReader(subReader(start, endAddr))
     def fork = forkAt(currentAddr)
-    
+
     def skipTree(tag: Int): Unit =
       if (tag >= firstLengthTreeTag) goto(readEnd())
       else if (tag >= firstNatASTTreeTag) { readNat(); skipTree() }
       else if (tag >= firstASTTreeTag) skipTree()
       else if (tag >= firstNatTreeTag) readNat()
     def skipTree(): Unit = skipTree(readByte())
-    
+
     def skipParams(): Unit =
       while (nextByte == PARAMS || nextByte == TYPEPARAM) skipTree()
 
@@ -112,7 +112,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       }
       else tag
     }
-    
+
     def readName(): TermName = toTermName(readNameRef())
 
     def readNameSplitSig()(implicit ctx: Context): Any /* TermName | (TermName, Signature) */ =
@@ -124,19 +124,19 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         case name =>
           toTermName(name)
       }
-    
+
 // ------ Reading types -----------------------------------------------------
-    
+
     /** Read names in an interleaved sequence of (parameter) names and types/bounds */
-    def readParamNames[N <: Name](end: Addr): List[N] = 
-      until(end) { 
+    def readParamNames[N <: Name](end: Addr): List[N] =
+      until(end) {
         val name = readName().asInstanceOf[N]
-        skipTree() 
+        skipTree()
         name
       }
 
     /** Read types or bounds in an interleaved sequence of (parameter) names and types/bounds */
-    def readParamTypes[T <: Type](end: Addr)(implicit ctx: Context): List[T] = 
+    def readParamTypes[T <: Type](end: Addr)(implicit ctx: Context): List[T] =
       until(end) { readNat(); readType().asInstanceOf[T] }
 
     /** Read referece to definition and return symbol created at that definition */
@@ -165,17 +165,17 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         typeAtAddr(start) = tp
         op
       }
-            
+
       def readLengthType(): Type = {
         val end = readEnd()
-        
+
         def readNamesSkipParams[N <: Name]: (List[N], TreeReader) = {
           val nameReader = fork
           nameReader.skipTree() // skip result
           val paramReader = nameReader.fork
           (nameReader.readParamNames[N](end), paramReader)
         }
-        
+
         val result =
           (tag: @switch) match {
             case SUPERtype =>
@@ -194,7 +194,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
               TypeBounds(readType(), readType())
             case TYPEALIAS =>
               val alias = readType()
-              val variance = 
+              val variance =
                 if (nextByte == COVARIANT) { readByte(); 1 }
                 else if (nextByte == CONTRAVARIANT) { readByte(); -1 }
                 else 0
@@ -235,9 +235,9 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         assert(currentAddr == end, s"$start $currentAddr $end ${astTagToString(tag)}")
         result
       }
-      
+
       def readSimpleType(): Type = (tag: @switch) match {
-        case TYPEREFdirect | TERMREFdirect => 
+        case TYPEREFdirect | TERMREFdirect =>
           NamedType.withFixedSym(NoPrefix, readSymRef())
         case TYPEREFsymbol | TERMREFsymbol =>
           readSymNameRef()
@@ -287,10 +287,10 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         case BYNAMEtype =>
           ExprType(readType())
       }
-      
+
       if (tag < firstLengthTreeTag) readSimpleType() else readLengthType()
     }
-    
+
     private def readSymNameRef()(implicit ctx: Context): Type = {
       val sym = readSymRef()
       val prefix = readType()
@@ -300,17 +300,17 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
           // without this precaution we get an infinite cycle when unpickling pos/extmethods.scala
           // the problem arises when a self type of a trait is a type parameter of the same trait.
         case _ => res
-      }      
+      }
     }
-    
+
     private def readPackageRef()(implicit ctx: Context): TermSymbol = {
       val name = readName()
       if (name == nme.ROOT) defn.RootPackage
       else if (name == nme.EMPTY_PACKAGE) defn.EmptyPackageVal
       else ctx.requiredPackage(name)
     }
-    
-    def readTypeRef(): Type = 
+
+    def readTypeRef(): Type =
       typeAtAddr(readAddr())
 
     def readPath()(implicit ctx: Context): Type = {
@@ -318,23 +318,23 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       assert(tp.isInstanceOf[SingletonType])
       tp
     }
-    
-    def readTermRef()(implicit ctx: Context): TermRef = 
+
+    def readTermRef()(implicit ctx: Context): TermRef =
       readType().asInstanceOf[TermRef]
 
 // ------ Reading definitions -----------------------------------------------------
-    
-    private def noRhs(end: Addr): Boolean = 
+
+    private def noRhs(end: Addr): Boolean =
       currentAddr == end || isModifierTag(nextByte)
-      
+
     private def localContext(owner: Symbol)(implicit ctx: Context) = {
       val lctx = ctx.fresh.setOwner(owner)
       if (owner.isClass) lctx.setScope(owner.unforcedDecls) else lctx.setNewScope
     }
-    
+
     private def normalizeFlags(tag: Int, givenFlags: FlagSet, name: Name, isAbstractType: Boolean, rhsIsEmpty: Boolean)(implicit ctx: Context): FlagSet = {
       val lacksDefinition =
-        rhsIsEmpty && 
+        rhsIsEmpty &&
           name.isTermName && !name.isConstructorName && !givenFlags.is(ParamOrAccessor) ||
         isAbstractType
       var flags = givenFlags
@@ -350,7 +350,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       flags
     }
 
-    /** Create symbol of definition node and enter in symAtAddr map 
+    /** Create symbol of definition node and enter in symAtAddr map
      *  @return  true iff the definition does not contain initialization code
      */
     def createSymbol()(implicit ctx: Context): Boolean = {
@@ -372,7 +372,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       val expandedFlag = if (rawName.isInstanceOf[TastyName.Expanded]) ExpandedName else EmptyFlags
       pickling.println(i"creating symbol $name at $start with flags $givenFlags")
       val flags = normalizeFlags(tag, givenFlags | expandedFlag, name, isAbstractType, rhsIsEmpty)
-      def adjustIfModule(completer: LazyType) = 
+      def adjustIfModule(completer: LazyType) =
         if (flags is Module) ctx.adjustModuleCompleter(completer, name) else completer
       val sym =
         roots.find(root => (root.owner eq ctx.owner) && root.name == name) match {
@@ -386,7 +386,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
           case _ =>
             val completer = adjustIfModule(new Completer(subReader(start, end)))
             if (isClass)
-              ctx.newClassSymbol(ctx.owner, name.asTypeName, flags, completer, 
+              ctx.newClassSymbol(ctx.owner, name.asTypeName, flags, completer,
                   privateWithin, coord = start.index)
             else {
               val sym = symAtAddr.get(start) match {
@@ -412,7 +412,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       tag != VALDEF || rhsIsEmpty
     }
 
-    /** Read modifier list into triplet of flags, annotations and a privateWithin 
+    /** Read modifier list into triplet of flags, annotations and a privateWithin
      *  boindary symbol.
      */
     def readModifiers(end: Addr)(implicit ctx: Context): (FlagSet, List[Annotation], Symbol) = {
@@ -452,7 +452,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
           case SCALA2X => addFlag(Scala2x)
           case DEFAULTparameterized => addFlag(DefaultParameterized)
           case INSUPERCALL => addFlag(InSuperCall)
-          case PRIVATEqualified => 
+          case PRIVATEqualified =>
             readByte()
             privateWithin = readType().typeSymbol
           case PROTECTEDqualified =>
@@ -470,23 +470,23 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       }
       (flags, annots.toList, privateWithin)
     }
-    
+
     /** Create symbols for a definitions in statement sequence between
      *  current address and `end`.
      *  @return  true iff none of the statements contains initialization code
      */
     def indexStats(end: Addr)(implicit ctx: Context): Boolean = {
-      val noInitss = 
-        until(end) { 
+      val noInitss =
+        until(end) {
           nextByte match {
-            case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM => 
-              createSymbol() 
-            case IMPORT => 
+            case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM =>
+              createSymbol()
+            case IMPORT =>
               skipTree()
               true
-            case PACKAGE => 
+            case PACKAGE =>
               processPackage { (pid, end) => implicit ctx => indexStats(end) }
-            case _ => 
+            case _ =>
               skipTree()
               false
           }
@@ -505,13 +505,13 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       val pid = ref(readTermRef()).asInstanceOf[RefTree]
       op(pid, end)(localContext(pid.symbol.moduleClass))
     }
-    
+
     /** Create symbols the longest consecutive sequence of parameters with given
      *  `tag starting at current address.
      */
     def indexParams(tag: Int)(implicit ctx: Context) =
       while (nextByte == tag) createSymbol()
-      
+
     /** Create symbols for all type and value parameters of template starting
      *  at current address.
      */
@@ -523,13 +523,13 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
     }
 
     /** If definition was already read by a completer, return the previously read tree
-     *  or else read definition. 
+     *  or else read definition.
      */
     def readIndexedDef()(implicit ctx: Context): Tree = treeAtAddr.remove(currentAddr) match {
       case Some(tree) => skipTree(); tree
       case none => readNewDef()
     }
-    
+
     private def readNewDef()(implicit ctx: Context): Tree = {
       val start = currentAddr
       val sym = symAtAddr(start)
@@ -540,7 +540,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         fork.indexParams(tag)
         readIndexedParams(tag)
       }
-    
+
       def readParamss(implicit ctx: Context): List[List[ValDef]] = {
         collectWhile(nextByte == PARAMS) {
           readByte()
@@ -548,19 +548,19 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
           readParams[ValDef](PARAM)
         }
       }
-      
-      def readRhs(implicit ctx: Context) = 
+
+      def readRhs(implicit ctx: Context) =
         if (noRhs(end)) EmptyTree
         else readLater(end, rdr => ctx => rdr.readTerm()(ctx))
 
       def localCtx = localContext(sym)
-      
-      def DefDef(tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree) = 
+
+      def DefDef(tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree) =
          ta.assignType(
             untpd.DefDef(
               sym.name.asTermName, tparams, vparamss, tpt, readRhs(localCtx)),
             sym)
-      
+
       def ta =  ctx.typeAssigner
 
       val name = readName()
@@ -599,18 +599,18 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
             DefDef(Nil, Nil, TypeTree(info))
           }
       }
-      val mods = 
+      val mods =
         if (sym.annotations.isEmpty) EmptyModifiers
         else Modifiers(annotations = sym.annotations.map(_.tree))
       tree.withMods(mods) // record annotations in tree so that tree positions can be filled in.
       goto(end)
       setPos(start, tree)
     }
-    
+
     private def readTemplate(implicit ctx: Context): Template = {
       val start = currentAddr
       val cls = ctx.owner.asClass
-      def setClsInfo(parents: List[TypeRef], selfType: Type) = 
+      def setClsInfo(parents: List[TypeRef], selfType: Type) =
         cls.info = ClassInfo(cls.owner.thisType, cls, parents, cls.unforcedDecls, selfType)
       setClsInfo(Nil, NoType)
       val localDummy = ctx.newLocalDummy(cls)
@@ -625,7 +625,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         }
       }
       val parentRefs = ctx.normalizeToClassRefs(parents.map(_.tpe), cls, cls.unforcedDecls)
-       val self = 
+       val self =
         if (nextByte == SELFDEF) {
           readByte()
           untpd.ValDef(readName(), readTpt(), EmptyTree).withType(NoType)
@@ -636,16 +636,16 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       if (noInits) cls.setFlag(NoInits)
       val constr = readIndexedDef().asInstanceOf[DefDef]
 
-      def mergeTypeParamsAndAliases(tparams: List[TypeDef], stats: List[Tree]): (List[Tree], List[Tree]) = 
+      def mergeTypeParamsAndAliases(tparams: List[TypeDef], stats: List[Tree]): (List[Tree], List[Tree]) =
         (tparams, stats) match {
-          case (tparam :: tparams1, (alias: TypeDef) :: stats1) 
+          case (tparam :: tparams1, (alias: TypeDef) :: stats1)
           if tparam.name == alias.name.expandedName(cls) =>
             val (tas, stats2) = mergeTypeParamsAndAliases(tparams1, stats1)
             (tparam :: alias :: tas, stats2)
           case _ =>
             (tparams, stats)
-        }            
-    
+        }
+
       val lazyStats = readLater(end, rdr => implicit ctx => {
         val stats0 = rdr.readIndexedStats(localDummy, end)
         val (tparamsAndAliases, stats) = mergeTypeParamsAndAliases(tparams, stats0)
@@ -655,29 +655,29 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         untpd.Template(constr, parents, self, lazyStats)
           .withType(localDummy.nonMemberTermRef))
     }
-    
+
     def readIndexedStat(exprOwner: Symbol)(implicit ctx: Context): Tree = nextByte match {
-      case TYPEDEF | VALDEF | DEFDEF | IMPORT => 
+      case TYPEDEF | VALDEF | DEFDEF | IMPORT =>
         readIndexedDef()
-      case IMPORT => 
+      case IMPORT =>
         ???
       case PACKAGE =>
         val start = currentAddr
         processPackage { (pid, end) => implicit ctx =>
           setPos(start, PackageDef(pid, readIndexedStats(exprOwner, end)(ctx)))
         }
-      case _ => 
+      case _ =>
         readTerm()(ctx.withOwner(exprOwner))
     }
-    
+
     def readIndexedStats(exprOwner: Symbol, end: Addr)(implicit ctx: Context): List[Tree] =
       until(end)(readIndexedStat(exprOwner))
-    
+
     def readStats(exprOwner: Symbol, end: Addr)(implicit ctx: Context): List[Tree] = {
       fork.indexStats(end)
       readIndexedStats(exprOwner, end)
-    } 
-    
+    }
+
     def readIndexedParams[T <: MemberDef](tag: Int)(implicit ctx: Context): List[T] =
       collectWhile(nextByte == tag) { readIndexedDef().asInstanceOf[T] }
 
@@ -702,7 +702,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
           untpd.Ident(readName()).withType(readType())
         case SELECT =>
           def readQual(name: Name) = {
-            val localCtx = 
+            val localCtx =
               if (name == nme.CONSTRUCTOR) ctx.fresh.addMode(Mode.InSuperCall) else ctx
             readTerm()(localCtx)
           }
@@ -716,7 +716,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
             case name: Name => readRest(name, Signature.NotAMethod)
             case (name: Name, sig: Signature) => readRest(name, sig)
           }
-          
+
         case NEW =>
           New(readTpt())
         case _ =>
@@ -728,12 +728,12 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
 
         val result =
           (tag: @switch) match {
-            case SUPER => 
+            case SUPER =>
               val qual = readTerm()
               val mixClass = ifBefore(end)(readType().typeSymbol, NoSymbol)
               val mixName = if (mixClass.exists) mixClass.name.asTypeName else tpnme.EMPTY
               tpd.Super(qual, mixName, ctx.mode.is(Mode.InSuperCall), mixClass)
-            case APPLY => 
+            case APPLY =>
               val fn = readTerm()
               val isJava = fn.tpe.isInstanceOf[JavaMethodType]
               def readArg() = readTerm() match {
@@ -784,7 +784,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
               Alternative(until(end)(readTerm()))
             case UNAPPLY =>
               val fn = readTerm()
-              val implicitArgs = 
+              val implicitArgs =
                 collectWhile(nextByte == IMPLICITarg) {
                   readByte()
                   readTerm()
@@ -798,19 +798,19 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         assert(currentAddr == end, s"$start $currentAddr $end ${astTagToString(tag)}")
         result
       }
-      
+
       val tree = if (tag < firstLengthTreeTag) readSimpleTerm() else readLengthTerm()
       tree.overwriteType(tree.tpe.simplified)
       setPos(start, tree)
     }
-    
+
     def readTpt()(implicit ctx: Context) = {
       val start = currentAddr
       val tp = readType()
       if (tp.exists) setPos(start, TypeTree(tp)) else EmptyTree
     }
 
-    def readCases(end: Addr)(implicit ctx: Context): List[CaseDef] = 
+    def readCases(end: Addr)(implicit ctx: Context): List[CaseDef] =
       collectWhile(nextByte == CASEDEF && currentAddr != end) { readCase()(ctx.fresh.setNewScope) }
 
     def readCase()(implicit ctx: Context): CaseDef = {
@@ -822,18 +822,18 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       val guard = ifBefore(end)(readTerm(), EmptyTree)
       setPos(start, CaseDef(pat, guard, rhs))
     }
-    
+
     def readLater[T <: AnyRef](end: Addr, op: TreeReader => Context => T): Trees.Lazy[T] = {
       val localReader = fork
       goto(end)
       new LazyReader(localReader, op)
     }
-    
+
 // ------ Hooks for positions ------------------------------------------------
-          
-    /** Record address from which tree was created as a temporary position in the tree. 
+
+    /** Record address from which tree was created as a temporary position in the tree.
      *  The temporary position contains deltas relative to the position of the (as yet unknown)
-     *  parent node. It is marked as a non-synthetic source position. 
+     *  parent node. It is marked as a non-synthetic source position.
      */
     def setPos[T <: Tree](addr: Addr, tree: T): T = {
       if (readPositions)
@@ -841,13 +841,13 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       tree
     }
   }
-  
+
   private def setNormalized(tree: Tree, parentPos: Position): Unit = {
     assert(tree.pos.exists)
     val absPos = Position(parentPos.start + offsetToInt(tree.pos.start), parentPos.end - tree.pos.end)
     tree.setPosUnchecked(absPos)
   }
-  
+
   def normalizePos(x: Any, parentPos: Position)(implicit ctx: Context): Unit =
     traverse(x, parentPos, setNormalized)
 
@@ -857,10 +857,10 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       val res = op(reader)(ctx.addMode(Mode.AllowDependentFunctions))
       normalizePos(res, parentPos)
       res
-    }  
+    }
   }
-  
-  class LazyAnnotationReader(sym: Symbol, reader: TreeReader) 
+
+  class LazyAnnotationReader(sym: Symbol, reader: TreeReader)
       extends LazyAnnotation(sym) with DeferredPosition {
     def complete(implicit ctx: Context) = {
       val res = reader.readTerm()
diff --git a/src/dotty/tools/dotc/core/pickling/UnPickler.scala b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
index a47b8bda2..7d220783b 100644
--- a/src/dotty/tools/dotc/core/pickling/UnPickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
@@ -368,7 +368,7 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot:
       def fromName(name: Name): Symbol = name.toTermName match {
         case nme.ROOT => loadingMirror.RootClass
         case nme.ROOTPKG => loadingMirror.RootPackage
-        case _ => 
+        case _ =>
           def declIn(owner: Symbol) = adjust(owner.info.decl(name))
           val sym = declIn(owner)
           if (sym.exists || owner.ne(defn.ObjectClass)) sym else declIn(defn.AnyClass)
@@ -687,7 +687,7 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot:
         if (decls.isEmpty) parent
         else {
           def addRefinement(tp: Type, sym: Symbol) = {
-            def subst(info: Type, rt: RefinedType) = 
+            def subst(info: Type, rt: RefinedType) =
               if (clazz.isClass) info.substThis(clazz.asClass, SkolemType(rt))
               else info // turns out some symbols read into `clazz` are not classes, not sure why this is the case.
             RefinedType(tp, sym.name, subst(sym.info, _))
diff --git a/src/dotty/tools/dotc/printing/PlainPrinter.scala b/src/dotty/tools/dotc/printing/PlainPrinter.scala
index ce33132ab..2762d9b51 100644
--- a/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -33,17 +33,17 @@ class PlainPrinter(_ctx: Context) extends Printer {
     ctx.warning("Exceeded recursion depth attempting to print.")
     (new Throwable).printStackTrace
   }
-  
+
   /** If true, tweak output so it is the same before and after pickling */
   protected def homogenizedView: Boolean = ctx.settings.YtestPickler.value
-  
-  def homogenize(tp: Type): Type = 
+
+  def homogenize(tp: Type): Type =
     if (homogenizedView)
       tp match {
         case tp: TypeVar if tp.isInstantiated => homogenize(tp.instanceOpt)
         case AndType(tp1, tp2) => homogenize(tp1) & homogenize(tp2)
         case OrType(tp1, tp2) => homogenize(tp1) | homogenize(tp2)
-        case _ => 
+        case _ =>
           val tp1 = tp.simplifyApply
           if (tp1 eq tp) tp else homogenize(tp1)
       }
@@ -159,9 +159,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
           toTextLocal(tp.instanceOpt) ~ "'" // debug for now, so that we can see where the TypeVars are.
         else {
           val constr = ctx.typerState.constraint
-          val bounds = 
-            if (constr.contains(tp)) constr.fullBounds(tp.origin) 
-            else TypeBounds.empty 
+          val bounds =
+            if (constr.contains(tp)) constr.fullBounds(tp.origin)
+            else TypeBounds.empty
           "(" ~ toText(tp.origin) ~ "?" ~ toText(bounds) ~ ")"
         }
       case _ =>
diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index d341ce00f..423c62044 100644
--- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -22,7 +22,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   def withEnclosingDef(enclDef: Tree[_ >: Untyped])(op: => Text): Text = {
     val savedCtx = myCtx
-    if (enclDef.hasType && enclDef.symbol.exists) 
+    if (enclDef.hasType && enclDef.symbol.exists)
       myCtx = ctx.withOwner(enclDef.symbol)
     val savedDef = enclosingDef
     enclosingDef = enclDef
@@ -158,7 +158,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     import untpd.{modsDeco => _, _}
 
     /** Print modifiers form symbols if tree has type, overriding the untpd behavior. */
-    implicit def modsDeco(mdef: untpd.MemberDef)(implicit ctx: Context): untpd.ModsDeco = 
+    implicit def modsDeco(mdef: untpd.MemberDef)(implicit ctx: Context): untpd.ModsDeco =
       tpd.modsDeco(mdef.asInstanceOf[tpd.MemberDef]).asInstanceOf[untpd.ModsDeco]
 
     def isLocalThis(tree: Tree) = tree.typeOpt match {
@@ -202,12 +202,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
     def useSymbol =
       tree.hasType && tree.symbol.exists && ctx.settings.YprintSyms.value
-          
+
     def modText(mods: untpd.Modifiers, kw: String): Text = { // DD
       val suppressKw = if (enclDefIsClass) mods is ParamAndLocal else mods is Param
-      var flagMask = 
+      var flagMask =
         if (ctx.settings.debugFlags.value) AllFlags
-        else if (suppressKw) PrintableFlags &~ Private 
+        else if (suppressKw) PrintableFlags &~ Private
         else PrintableFlags
       if (homogenizedView && mods.flags.isTypeFlags) flagMask &~= Implicit // drop implicit from classes
       val flagsText = (mods.flags & flagMask).toString
@@ -257,7 +257,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       prefix ~ (" extends" provided !ofNew) ~~ parentsText ~~ bodyText
     }
 
-    def toTextPackageId(pid: Tree): Text = 
+    def toTextPackageId(pid: Tree): Text =
       if (homogenizedView) toTextLocal(pid.tpe)
       else toTextLocal(pid)
 
@@ -364,7 +364,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         ("(" ~ toTextGlobal(implicits, ", ") ~ ")" provided implicits.nonEmpty)
       case tree @ ValDef(name, tpt, _) =>
         dclTextOr {
-          modText(tree.mods, if (tree.mods is Mutable) "var" else "val") ~~ 
+          modText(tree.mods, if (tree.mods is Mutable) "var" else "val") ~~
           nameIdText(tree) ~ optAscription(tpt) ~
           withEnclosingDef(tree) { optText(tree.rhs)(" = " ~ _) }
         }
@@ -372,14 +372,14 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         dclTextOr {
           val prefix = modText(tree.mods, "def") ~~ nameIdText(tree)
           withEnclosingDef(tree) {
-            addVparamssText(prefix ~ tparamsText(tparams), vparamss) ~ optAscription(tpt) ~ 
+            addVparamssText(prefix ~ tparamsText(tparams), vparamss) ~ optAscription(tpt) ~
             optText(tree.rhs)(" = " ~ _)
           }
         }
       case tree @ TypeDef(name, rhs) =>
         def typeDefText(rhsText: Text) =
           dclTextOr {
-            modText(tree.mods, "type") ~~ nameIdText(tree) ~ 
+            modText(tree.mods, "type") ~~ nameIdText(tree) ~
             withEnclosingDef(tree) {
               val rhsText1 = if (tree.hasType) toText(tree.symbol.info) else rhsText
               tparamsText(tree.tparams) ~ rhsText1
@@ -387,7 +387,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           }
         rhs match {
           case impl: Template =>
-            modText(tree.mods, if ((tree).mods is Trait) "trait" else "class") ~~ 
+            modText(tree.mods, if ((tree).mods is Trait) "trait" else "class") ~~
             nameIdText(tree) ~ withEnclosingDef(tree) { toTextTemplate(impl) } ~
             (if (tree.hasType && ctx.settings.verbose.value) s"[decls = ${tree.symbol.info.decls}]" else "")
           case rhs: TypeBoundsTree =>
@@ -413,7 +413,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val bodyText =
           if (currentPrecedence == TopLevelPrec) "\n" ~ statsText else " {" ~ statsText ~ "}"
         "package " ~ toTextPackageId(pid) ~ bodyText
-      case tree: Template => 
+      case tree: Template =>
         toTextTemplate(tree)
       case Annotated(annot, arg) =>
         toTextLocal(arg) ~~ annotText(annot)
@@ -517,7 +517,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   def optText[T >: Untyped](tree: List[Tree[T]])(encl: Text => Text): Text =
     if (tree.exists(!_.isEmpty)) encl(blockText(tree)) else ""
-      
+
   override protected def polyParamName(name: TypeName): TypeName =
     name.unexpandedName
 
diff --git a/src/dotty/tools/dotc/reporting/Reporter.scala b/src/dotty/tools/dotc/reporting/Reporter.scala
index 223fc33d5..71a908397 100644
--- a/src/dotty/tools/dotc/reporting/Reporter.scala
+++ b/src/dotty/tools/dotc/reporting/Reporter.scala
@@ -89,7 +89,7 @@ trait Reporting { this: Context =>
 
   def warning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
     reporter.report(new Warning(msg, pos))
-    
+
   def strictWarning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
     if (this.settings.strict.value) error(msg, pos)
     else warning(msg + "\n(This would be an error under strict mode)", pos)
diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala
index 318d15c9e..cd64497e9 100644
--- a/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/src/dotty/tools/dotc/transform/Constructors.scala
@@ -185,7 +185,7 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor
           if (acc.name != nme.OUTER) assigns
           else {
             // insert test: if ($outer eq null) throw new NullPointerException
-            val nullTest = 
+            val nullTest =
               If(ref(param).select(defn.Object_eq).appliedTo(Literal(Constant(null))),
                  Throw(New(defn.NullPointerExceptionClass.typeRef, Nil)),
                  unitLiteral)
diff --git a/src/dotty/tools/dotc/transform/ElimByName.scala b/src/dotty/tools/dotc/transform/ElimByName.scala
index 5bd9c045a..2d0ecaf99 100644
--- a/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -73,7 +73,7 @@ class ElimByName extends MiniPhaseTransform with InfoTransformer { thisTransform
       case formalExpr: ExprType =>
         val argType = arg.tpe.widen
         val argFun = arg match {
-          case Apply(Select(qual, nme.apply), Nil) 
+          case Apply(Select(qual, nme.apply), Nil)
           if qual.tpe.derivesFrom(defn.FunctionClass(0)) && isPureExpr(qual) =>
             qual
           case _ =>
diff --git a/src/dotty/tools/dotc/transform/ElimRepeated.scala b/src/dotty/tools/dotc/transform/ElimRepeated.scala
index 28131e1e9..414d09541 100644
--- a/src/dotty/tools/dotc/transform/ElimRepeated.scala
+++ b/src/dotty/tools/dotc/transform/ElimRepeated.scala
@@ -59,9 +59,9 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
     transformTypeOfTree(tree)
 
   override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    val args1 = tree.args.map { 
+    val args1 = tree.args.map {
       case arg: Typed if isWildcardStarArg(arg) =>
-        if (tree.fun.symbol.is(JavaDefined) && arg.expr.tpe.derivesFrom(defn.SeqClass)) 
+        if (tree.fun.symbol.is(JavaDefined) && arg.expr.tpe.derivesFrom(defn.SeqClass))
           seqToArray(arg.expr)
         else arg.expr
       case arg => arg
@@ -71,7 +71,7 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
 
   /** Convert sequence argument to Java array */
   private def seqToArray(tree: Tree)(implicit ctx: Context): Tree = tree match {
-    case SeqLiteral(elems) => 
+    case SeqLiteral(elems) =>
       JavaSeqLiteral(elems)
     case _ =>
       val elemType = tree.tpe.firstBaseArgInfo(defn.SeqClass)
@@ -84,7 +84,7 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
         .ensureConforms(defn.ArrayType(elemType))
           // Because of phantomclasses, the Java array's type might not conform to the resturn type
   }
-  
+
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree =
     transformTypeOfTree(tree)
 
diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index 3674f7375..ab124402a 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -258,7 +258,7 @@ object Erasure extends TypeTestsCasts{
     override def typedLiteral(tree: untpd.Literal)(implicit ctc: Context): Literal =
       if (tree.typeOpt.isRef(defn.UnitClass)) tree.withType(tree.typeOpt)
       else super.typedLiteral(tree)
-      
+
     /** Type check select nodes, applying the following rewritings exhaustively
      *  on selections `e.m`, where `OT` is the type of the owner of `m` and `ET`
      *  is the erased type of the selection's original qualifier expression.
@@ -395,19 +395,19 @@ object Erasure extends TypeTestsCasts{
     }
 
     // The following four methods take as the proto-type the erasure of the pre-existing type,
-    // if the original proto-type is not a value type. 
+    // if the original proto-type is not a value type.
     // This makes all branches be adapted to the correct type.
     override def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(implicit ctx: Context) =
       super.typedSeqLiteral(tree, erasure(tree.typeOpt))
-        // proto type of typed seq literal is original type; 
+        // proto type of typed seq literal is original type;
 
     override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context) =
       super.typedIf(tree, adaptProto(tree, pt))
-   
+
     override def typedMatch(tree: untpd.Match, pt: Type)(implicit ctx: Context) =
       super.typedMatch(tree, adaptProto(tree, pt))
-    
-    override def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context) = 
+
+    override def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context) =
       super.typedTry(tree, adaptProto(tree, pt))
 
     private def adaptProto(tree: untpd.Tree, pt: Type)(implicit ctx: Context) = {
diff --git a/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index 579ff9322..8baaa3a11 100644
--- a/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -297,9 +297,9 @@ object ExplicitOuter {
       case ex: ClassCastException =>
         throw new ClassCastException(i"no path exists from ${ctx.owner.enclosingClass} to $toCls")
     }
-    
-    /** The outer parameter definition of a constructor if it needs one */ 
-    def paramDefs(constr: Symbol): List[ValDef] = 
+
+    /** The outer parameter definition of a constructor if it needs one */
+    def paramDefs(constr: Symbol): List[ValDef] =
       if (constr.isConstructor && hasOuterParam(constr.owner.asClass)) {
         val MethodType(outerName :: _, outerType :: _) = constr.info
         val outerSym = ctx.newSymbol(constr, outerName, Param, outerType)
diff --git a/src/dotty/tools/dotc/transform/FirstTransform.scala b/src/dotty/tools/dotc/transform/FirstTransform.scala
index b8d2b44f3..cfe650b99 100644
--- a/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -87,7 +87,7 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
       case stat: TypeDef if singleClassDefs contains stat.name =>
         val objName = stat.name.toTermName
         val nameClash = stats.exists {
-          case other: MemberDef => 
+          case other: MemberDef =>
             other.name == objName && other.symbol.info.isParameterless
           case _ =>
             false
@@ -99,7 +99,7 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
 
     def skipJava(stats: List[Tree]): List[Tree] = // packages get a JavaDefined flag. Dont skip them
       stats.filter(t => !(t.symbol is(Flags.JavaDefined, Flags.Package)))
-    
+
     addMissingCompanions(reorder(skipJava(stats)))
   }
 
diff --git a/src/dotty/tools/dotc/transform/NormalizeFlags.scala b/src/dotty/tools/dotc/transform/NormalizeFlags.scala
index bdec800c7..2f5907b75 100644
--- a/src/dotty/tools/dotc/transform/NormalizeFlags.scala
+++ b/src/dotty/tools/dotc/transform/NormalizeFlags.scala
@@ -9,7 +9,7 @@ import SymDenotations.SymDenotation
 import TreeTransforms.MiniPhaseTransform
 import Flags._, Symbols._
 
-/** 1. Widens all private[this] and protected[this] qualifiers to just private/protected 
+/** 1. Widens all private[this] and protected[this] qualifiers to just private/protected
  *  2. Sets PureInterface flag for traits that only have pure interface members and that
  *     do not have initialization code. A pure interface member is either an abstract
  *     or alias type definition or a deferred val or def.
@@ -19,12 +19,12 @@ class NormalizeFlags extends MiniPhaseTransform with SymTransformer { thisTransf
 
   def transformSym(ref: SymDenotation)(implicit ctx: Context) = {
     var newFlags = ref.flags &~ Local
-    if (ref.is(NoInitsTrait) && ref.info.decls.forall(isPureInterfaceMember)) 
+    if (ref.is(NoInitsTrait) && ref.info.decls.forall(isPureInterfaceMember))
       newFlags |= PureInterface
     if (newFlags != ref.flags) ref.copySymDenotation(initFlags = newFlags)
     else ref
   }
-  
-  private def isPureInterfaceMember(sym: Symbol)(implicit ctx: Context) = 
+
+  private def isPureInterfaceMember(sym: Symbol)(implicit ctx: Context) =
     if (sym.isTerm) sym.is(Deferred) else !sym.isClass
 }
diff --git a/src/dotty/tools/dotc/transform/Pickler.scala b/src/dotty/tools/dotc/transform/Pickler.scala
index b3caaa19b..445fed2c4 100644
--- a/src/dotty/tools/dotc/transform/Pickler.scala
+++ b/src/dotty/tools/dotc/transform/Pickler.scala
@@ -16,15 +16,15 @@ class Pickler extends Phase {
   import ast.tpd._
 
   override def phaseName: String = "pickler"
-  
+
   private def output(name: String, msg: String) = {
     val s = new PrintStream(name)
     s.print(msg)
     s.close
   }
-  
+
   private val beforePickling = new mutable.HashMap[CompilationUnit, String]
-  
+
   override def run(implicit ctx: Context): Unit = {
     val unit = ctx.compilationUnit
     if (!unit.isJava) {
@@ -46,25 +46,25 @@ class Pickler extends Phase {
         }
       // println(i"rawBytes = \n$rawBytes%\n%") // DEBUG
       if (pickling ne noPrinter) new TastyPrinter(pickler.assembleParts()).printContents()
-    } 
+    }
   }
-  
+
   override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
     val result = super.runOn(units)
-    if (ctx.settings.YtestPickler.value) 
+    if (ctx.settings.YtestPickler.value)
       testUnpickler(units)(ctx.fresh.setPeriod(Period(ctx.runId + 1, FirstPhaseId)))
     result
   }
-  
+
   private def testUnpickler(units: List[CompilationUnit])(implicit ctx: Context): Unit = {
     pickling.println(i"testing unpickler at run ${ctx.runId}")
     ctx.definitions.init
-    val unpicklers = 
+    val unpicklers =
       for (unit <- units) yield {
         val unpickler = new DottyUnpickler(unit.pickler.assembleParts())
         unpickler.enter(roots = Set())
         unpickler
-      }  
+      }
     pickling.println("************* entered toplevel ***********")
     for ((unpickler, unit) <- unpicklers zip units) {
       val unpickled = unpickler.body(readPositions = false)
@@ -72,7 +72,7 @@ class Pickler extends Phase {
     }
   }
 
-  private def testSame(unpickled: String, previous: String, unit: CompilationUnit)(implicit ctx: Context) = 
+  private def testSame(unpickled: String, previous: String, unit: CompilationUnit)(implicit ctx: Context) =
     if (previous != unpickled) {
       output("before-pickling.txt", previous)
       output("after-pickling.txt", unpickled)
diff --git a/src/dotty/tools/dotc/transform/ResolveSuper.scala b/src/dotty/tools/dotc/transform/ResolveSuper.scala
index 921a5f1fa..9c0e34256 100644
--- a/src/dotty/tools/dotc/transform/ResolveSuper.scala
+++ b/src/dotty/tools/dotc/transform/ResolveSuper.scala
@@ -48,7 +48,7 @@ class ResolveSuper extends MiniPhaseTransform with IdentityDenotTransformer { th
 
   override def phaseName: String = "resolveSuper"
 
-  override def runsAfter = Set(classOf[ElimByName]) // verified empirically, need to figure out what the reason is. 
+  override def runsAfter = Set(classOf[ElimByName]) // verified empirically, need to figure out what the reason is.
 
   /** Returns the symbol that is accessed by a super-accessor in a mixin composition.
    *
diff --git a/src/dotty/tools/dotc/transform/RestoreScopes.scala b/src/dotty/tools/dotc/transform/RestoreScopes.scala
index 0eb1935a6..3a168b1fe 100644
--- a/src/dotty/tools/dotc/transform/RestoreScopes.scala
+++ b/src/dotty/tools/dotc/transform/RestoreScopes.scala
@@ -24,7 +24,7 @@ class RestoreScopes extends MiniPhaseTransform with IdentityDenotTransformer { t
 
   override def transformTypeDef(tree: TypeDef)(implicit ctx: Context, info: TransformerInfo) = {
     val TypeDef(_, impl: Template) = tree
-    // 
+    //
     val restoredDecls = newScope
     for (stat <- impl.constr :: impl.body)
       if (stat.isInstanceOf[MemberDef] && stat.symbol.exists)
@@ -33,7 +33,7 @@ class RestoreScopes extends MiniPhaseTransform with IdentityDenotTransformer { t
       // For top-level classes this does nothing.
     val cls = tree.symbol.asClass
     val pkg = cls.owner.asClass
-    pkg.enter(cls) 
+    pkg.enter(cls)
     val cinfo = cls.classInfo
     tree.symbol.copySymDenotation(
       info = cinfo.derivedClassInfo( // Dotty deviation: Cannot expand cinfo inline without a type error
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index 31a37eb09..af5a9a1f2 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -183,13 +183,13 @@ class TreeChecker extends Phase with SymTransformer {
       phasesToCheck.foreach(_.checkPostCondition(res))
       res
     }
-    
+
     /** Check that PolyParams and MethodParams refer to an enclosing type */
     def checkNoOrphans(tp: Type)(implicit ctx: Context) = new TypeMap() {
       val definedBinders = mutable.Set[Type]()
       def apply(tp: Type): Type = {
         tp match {
-          case tp: BindingType => 
+          case tp: BindingType =>
             definedBinders += tp
             mapOver(tp)
             definedBinders -= tp
diff --git a/src/dotty/tools/dotc/typer/EtaExpansion.scala b/src/dotty/tools/dotc/typer/EtaExpansion.scala
index b59748247..1c0e6a11f 100644
--- a/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -37,7 +37,7 @@ object EtaExpansion {
     case Apply(MaybePoly(fn @ Select(pre, name), targs), args) =>
       cpy.Apply(tree)(
         cpy.Select(fn)(
-          lift(defs, pre), name).appliedToTypeTrees(targs), 
+          lift(defs, pre), name).appliedToTypeTrees(targs),
           liftArgs(defs, fn.tpe, args))
     case Select(pre, name) =>
       cpy.Select(tree)(lift(defs, pre), name)
diff --git a/src/dotty/tools/dotc/typer/Implicits.scala b/src/dotty/tools/dotc/typer/Implicits.scala
index 1f5fd3899..2c7aaaeb1 100644
--- a/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/src/dotty/tools/dotc/typer/Implicits.scala
@@ -455,7 +455,7 @@ trait Implicits { self: Typer =>
     private def nestedContext = ctx.fresh.setMode(ctx.mode &~ Mode.ImplicitsEnabled)
 
     private def implicitProto(resultType: Type, f: Type => Type) =
-      if (argument.isEmpty) f(resultType) else ViewProto(f(argument.tpe.widen), f(resultType)) 
+      if (argument.isEmpty) f(resultType) else ViewProto(f(argument.tpe.widen), f(resultType))
         // Not clear whether we need to drop the `.widen` here. All tests pass with it in place, though.
 
     assert(argument.isEmpty || argument.tpe.isValueType || argument.tpe.isInstanceOf[ExprType],
diff --git a/src/dotty/tools/dotc/typer/Inferencing.scala b/src/dotty/tools/dotc/typer/Inferencing.scala
index 424575f8c..0223260a0 100644
--- a/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -163,7 +163,7 @@ trait Inferencing { this: Checking =>
    *  If such a variable appears covariantly in type `tp` or does not appear at all,
    *  approximate it by its lower bound. Otherwise, if it appears contravariantly
    *  in type `tp` approximate it by its upper bound.
-   *  @param ownedBy  if it is different from NoSymbol, all type variables owned by 
+   *  @param ownedBy  if it is different from NoSymbol, all type variables owned by
    *                  `ownedBy` qualify, independent of position.
    *                  Without that second condition, it can be that certain variables escape
    *                  interpolation, for instance when their tree was eta-lifted, so
@@ -173,7 +173,7 @@ trait Inferencing { this: Checking =>
    */
   def interpolateUndetVars(tree: Tree, ownedBy: Symbol)(implicit ctx: Context): Unit = {
     val constraint = ctx.typerState.constraint
-    val qualifies = (tvar: TypeVar) => 
+    val qualifies = (tvar: TypeVar) =>
       (tree contains tvar.owningTree) || ownedBy.exists && tvar.owner == ownedBy
     def interpolate() = Stats.track("interpolateUndetVars") {
       val tp = tree.tpe.widen
diff --git a/src/dotty/tools/dotc/typer/Mode.scala b/src/dotty/tools/dotc/typer/Mode.scala
index 95c15f8ab..997741819 100644
--- a/src/dotty/tools/dotc/typer/Mode.scala
+++ b/src/dotty/tools/dotc/typer/Mode.scala
@@ -31,8 +31,8 @@ object Mode {
   val ImplicitsEnabled = newMode(2, "ImplicitsEnabled")
   val InferringReturnType = newMode(3, "InferringReturnType")
 
-  /** This mode bit is set if we collect information without reference to a valid 
-   *  context with typerstate and constraint. This is typically done when we 
+  /** This mode bit is set if we collect information without reference to a valid
+   *  context with typerstate and constraint. This is typically done when we
    *  cache the eligibility of implicits. Caching needs to be done across different constraints.
    *  Therefore, if TypevarsMissContext is set, subtyping becomes looser, and assumes
    *  that PolyParams can be sub- and supertypes of anything. See TypeComparer.
@@ -56,7 +56,7 @@ object Mode {
 
   /** Allow GADTFlexType labelled types to have their bounds adjusted */
   val GADTflexible = newMode(8, "GADTflexible")
-  
+
   /** Allow dependent functions. This is currently necessary for unpickling, because
    *  some dependent functions are passed through from the front end(s?), even though they
    *  are technically speaking illegal.
diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala
index 01c1c28ab..10667f884 100644
--- a/src/dotty/tools/dotc/typer/Namer.scala
+++ b/src/dotty/tools/dotc/typer/Namer.scala
@@ -18,7 +18,7 @@ import config.Printers._
 import language.implicitConversions
 
 trait NamerContextOps { this: Context =>
- 
+
   /** Enter symbol into current class, if current class is owner of current context,
    *  or into current scope, if not. Should always be called instead of scope.enter
    *  in order to make sure that updates to class members are reflected in
@@ -83,7 +83,7 @@ trait NamerContextOps { this: Context =>
   /** The given type, unless `sym` is a constructor, in which case the
    *  type of the constructed instance is returned
    */
-  def effectiveResultType(sym: Symbol, typeParams: List[Symbol], given: Type) = 
+  def effectiveResultType(sym: Symbol, typeParams: List[Symbol], given: Type) =
     if (sym.name == nme.CONSTRUCTOR) sym.owner.typeRef.appliedTo(typeParams map (_.typeRef))
     else given
 
@@ -112,19 +112,19 @@ trait NamerContextOps { this: Context =>
     else if (valueParamss.isEmpty) ExprType(monotpe)
     else monotpe
   }
-  
+
   /** Find moduleClass/sourceModule in effective scope */
   private def findModuleBuddy(name: Name)(implicit ctx: Context) = {
     val scope = effectiveScope
     val it = scope.lookupAll(name).filter(_ is Module)
     assert(it.hasNext, s"no companion $name in $scope")
     it.next
-  }      
+  }
 
   /** Add moduleClass or sourceModule functionality to completer
    *  for a module or module class
    */
-  def adjustModuleCompleter(completer: LazyType, name: Name) = 
+  def adjustModuleCompleter(completer: LazyType, name: Name) =
     if (name.isTermName)
       completer withModuleClass (_ => findModuleBuddy(name.moduleClassName))
     else
@@ -233,9 +233,9 @@ class Namer { typer: Typer =>
 
     /** Add moduleClass/sourceModule to completer if it is for a module val or class */
     def adjustIfModule(completer: LazyType, tree: MemberDef) =
-      if (tree.mods is Module) ctx.adjustModuleCompleter(completer, tree.name.encode) 
+      if (tree.mods is Module) ctx.adjustModuleCompleter(completer, tree.name.encode)
       else completer
-      
+
     typr.println(i"creating symbol for $tree in ${ctx.mode}")
 
     def checkNoConflict(name: Name): Unit = {
@@ -689,11 +689,11 @@ class Namer { typer: Typer =>
         lhsType orElse WildcardType
       }
     }
-    
+
     val tptProto = mdef.tpt match {
-      case _: untpd.DerivedTypeTree => 
+      case _: untpd.DerivedTypeTree =>
         WildcardType
-      case TypeTree(untpd.EmptyTree) => 
+      case TypeTree(untpd.EmptyTree) =>
         inferredType
       case TypedSplice(tpt: TypeTree) if !isFullyDefined(tpt.tpe, ForceDegree.none) =>
         val rhsType = typedAheadExpr(mdef.rhs, tpt.tpe).tpe
@@ -708,7 +708,7 @@ class Namer { typer: Typer =>
           case _ =>
         }
         WildcardType
-      case _ => 
+      case _ =>
         WildcardType
     }
     paramFn(typedAheadType(mdef.tpt, tptProto).tpe)
@@ -742,7 +742,7 @@ class Namer { typer: Typer =>
     val isDerived = tdef.rhs.isInstanceOf[untpd.DerivedTypeTree]
     val toParameterize = tparamSyms.nonEmpty && !isDerived
     val needsLambda = sym.allOverriddenSymbols.exists(_ is HigherKinded) && !isDerived
-    def abstracted(tp: Type): Type = 
+    def abstracted(tp: Type): Type =
       if (needsLambda) tp.LambdaAbstract(tparamSyms)
       else if (toParameterize) tp.parameterizeWith(tparamSyms)
       else tp
diff --git a/src/dotty/tools/dotc/typer/ProtoTypes.scala b/src/dotty/tools/dotc/typer/ProtoTypes.scala
index ac58615aa..eb5758662 100644
--- a/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -165,7 +165,7 @@ object ProtoTypes {
   case class FunProto(args: List[untpd.Tree], resType: Type, typer: Typer)(implicit ctx: Context)
   extends UncachedGroundType with ApplyingProto {
     private var myTypedArgs: List[Tree] = Nil
-    
+
     override def resultType(implicit ctx: Context) = resType
 
     /** A map in which typed arguments can be stored to be later integrated in `typedArgs`. */
@@ -247,7 +247,7 @@ object ProtoTypes {
   extends CachedGroundType with ApplyingProto {
 
     override def resultType(implicit ctx: Context) = resType
-    
+
     def isMatchedBy(tp: Type)(implicit ctx: Context): Boolean =
       ctx.typer.isApplicable(tp, argType :: Nil, resultType)
 
@@ -383,7 +383,7 @@ object ProtoTypes {
       tp.derivedRefinedType(wildApprox(tp.parent, theMap), tp.refinedName, wildApprox(tp.refinedInfo, theMap))
     case tp: TypeAlias => // default case, inlined for speed
       tp.derivedTypeAlias(wildApprox(tp.alias, theMap))
-    case tp @ PolyParam(poly, pnum) => 
+    case tp @ PolyParam(poly, pnum) =>
       ctx.typerState.constraint.entry(tp) match {
         case bounds: TypeBounds => wildApprox(WildcardType(bounds))
         case NoType => WildcardType(wildApprox(poly.paramBounds(pnum)).bounds)
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 5ef3a768c..2ec510a3d 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -30,10 +30,10 @@ trait TypeAssigner {
 
   /** An upper approximation of the given type `tp` that does not refer to any symbol in `symsToAvoid`.
    *  Approximation steps are:
-   *  
+   *
    *   - follow aliases if the original refers to a forbidden symbol
    *   - widen termrefs that refer to a forbidden symbol
-   *   - replace ClassInfos of forbidden classes by the intersection of their parents, refined by all 
+   *   - replace ClassInfos of forbidden classes by the intersection of their parents, refined by all
    *     non-private fields, methods, and type members.
    *   - drop refinements referring to a forbidden symbol.
    */
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index b066f1fc1..6befe58df 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -402,8 +402,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         typed(cpy.Apply(lhs)(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
       case untpd.TypedSplice(Apply(MaybePoly(Select(fn, app), targs), args)) if app == nme.apply =>
         val rawUpdate: untpd.Tree = untpd.Select(untpd.TypedSplice(fn), nme.update)
-        val wrappedUpdate = 
-          if (targs.isEmpty) rawUpdate 
+        val wrappedUpdate =
+          if (targs.isEmpty) rawUpdate
           else untpd.TypeApply(rawUpdate, targs map untpd.TypedSplice)
         val appliedUpdate = cpy.Apply(fn)(wrappedUpdate, (args map untpd.TypedSplice) :+ tree.rhs)
         typed(appliedUpdate, pt)
@@ -471,7 +471,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
    */
   protected def ensureNoLocalRefs(tree: Tree, pt: Type, localSyms: => List[Symbol], forcedDefined: Boolean = false)(implicit ctx: Context): Tree = {
     def ascribeType(tree: Tree, pt: Type): Tree = tree match {
-      case block @ Block(stats, expr) => 
+      case block @ Block(stats, expr) =>
         val expr1 = ascribeType(expr, pt)
         cpy.Block(block)(stats, expr1) withType expr1.tpe // no assignType here because avoid is redundant
       case _ =>
@@ -722,8 +722,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       if (tree.from.isEmpty) enclMethInfo(ctx)
       else {
         val from = tree.from.asInstanceOf[tpd.Tree]
-        val proto = 
-          if (ctx.erasedTypes) from.symbol.info.finalResultType 
+        val proto =
+          if (ctx.erasedTypes) from.symbol.info.finalResultType
           else WildcardType // We cannot reliably detect the internal type view of polymorphic or dependent methods
                             // because we do not know the internal type params and method params.
                             // Hence no adaptation is possible, and we assume WildcardType as prototype.
diff --git a/src/dotty/tools/dotc/util/Positions.scala b/src/dotty/tools/dotc/util/Positions.scala
index b9075c4a1..60274c71f 100644
--- a/src/dotty/tools/dotc/util/Positions.scala
+++ b/src/dotty/tools/dotc/util/Positions.scala
@@ -21,7 +21,7 @@ object Positions {
   /** Convert offset `x` to an integer by sign extending the original
    *  field of `StartEndBits` width.
    */
-  def offsetToInt(x: Int) = 
+  def offsetToInt(x: Int) =
     x << (32 - StartEndBits) >> (32 - StartEndBits)
 
   /** A position indicates a range between a start offset and an end offset.
@@ -124,7 +124,7 @@ object Positions {
       ((end & StartEndMask).toLong << StartEndBits) |
       (pointDelta.toLong << (StartEndBits * 2)))
   }
-  
+
   /** A synthetic position with given start and end */
   def Position(start: Int, end: Int): Position = {
     val pos = fromOffsets(start, end, SyntheticPointDelta)
diff --git a/src/dotty/tools/dotc/util/Util.scala b/src/dotty/tools/dotc/util/Util.scala
index 02c34bc35..0d37f687b 100644
--- a/src/dotty/tools/dotc/util/Util.scala
+++ b/src/dotty/tools/dotc/util/Util.scala
@@ -2,27 +2,27 @@ package dotty.tools.dotc.util
 import reflect.ClassTag
 
 object Util {
-  
+
   /** The index `i` in `candidates.indices` such that `candidates(i) <= x` and
    *  `candidates(i)` is closest to `x`, determined by binary search, or -1
    *  if `x < candidates(0)`.
    *  @param  hint   If between 0 and `candidates.length` use this
-   *                 as the first search point, otherwise use 
+   *                 as the first search point, otherwise use
    *                 `candidates.length/2`.
    *  @pre   candidates is sorted
    */
   def bestFit(candidates: Array[Int], length: Int, x: Int, hint: Int = -1): Int = {
     def recur(lo: Int, hi: Int, mid: Int): Int =
-      if (x < candidates(mid)) 
+      if (x < candidates(mid))
         recur(lo, mid - 1, (lo + mid - 1) / 2)
-      else if (mid + 1 < length && x >= candidates(mid + 1)) 
+      else if (mid + 1 < length && x >= candidates(mid + 1))
         recur(mid + 1, hi, (mid + 1 + hi) / 2)
       else mid
     val initMid = if (0 <= hint && hint < length) hint else length / 2
     if (length == 0 || x < candidates(0)) -1
     else recur(0, length, initMid)
   }
-  
+
   /** An array twice the size of given array, with existing elements copied over */
   def dble[T: ClassTag](arr: Array[T]) = {
     val arr1 = new Array[T](arr.length * 2)
-- 
cgit v1.2.3