Remove trailing whitespace

I have figured out how to make this the default in Eclipse, so hopefully
we won't see many repeats of this.

Author: odersky

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

@@ -210,9 +210,9 @@ object SymDenotations {
     /** Does this denotation have an annotation matching the given class symbol? */
     final def hasAnnotation(cls: Symbol)(implicit ctx: Context) =
       dropOtherAnnotations(annotations, cls).nonEmpty
-      
+
     /** Apply transform `f` to all annotations of this denotation */
-    final def transformAnnotations(f: Annotation => Annotation)(implicit ctx: Context): Unit = 
+    final def transformAnnotations(f: Annotation => Annotation)(implicit ctx: Context): Unit =
       annotations = annotations.mapConserve(f)
 
     /** Optionally, the annotation matching the given class symbol */

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

@@ -560,7 +560,7 @@ object Symbols {
 
   /** The Definitions object */
   def defn(implicit ctx: Context): Definitions = ctx.definitions
-  
+
   /** The current class */
   def currentClass(implicit ctx: Context): ClassSymbol = ctx.owner.enclosingClass.asClass
 

src/dotty/tools/dotc/core/TypeApplications.scala

@@ -279,7 +279,7 @@ class TypeApplications(val self: Type) extends AnyVal {
         default
     }
   }
-  
+
   /** Translate a type of the form From[T] to To[T], keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
    */

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

@@ -1788,12 +1788,12 @@ object Types {
         if (false) RefinedType(parent, refinedName, refinedInfo)
         else RefinedType(parent, refinedName, rt => refinedInfo.substSkolem(this, SkolemType(rt)))
     }
-    
+
     /** Add this refinement to `parent`, provided If `refinedName` is a member of `parent`. */
     def wrapIfMember(parent: Type)(implicit ctx: Context): Type =
       if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
       else parent
-      
+
     override def equals(that: Any) = that match {
       case that: RefinedType =>
         this.parent == that.parent &&
@@ -2414,7 +2414,7 @@ object Types {
         selfTypeCache = {
           def fullRef = fullyAppliedRef(cls.typeRef, cls.typeParams)
           val given = givenSelfType
-          val raw = 
+          val raw =
             if (!given.exists) fullRef
             else if (cls is Module) given
             else if (ctx.erasedTypes) fullRef
@@ -2423,7 +2423,7 @@ object Types {
         }
       selfTypeCache
     }
-    
+
     /** The explicitly given self type (self types of modules are assumed to be
      *  explcitly given here).
      */

src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala

@@ -669,7 +669,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       case _ =>
         readTerm()(ctx.withOwner(exprOwner))
     }
-    
+
     def readImport()(implicit ctx: Context): Tree = {
       readByte()
       readEnd()

src/dotty/tools/dotc/transform/ExtensionMethods.scala

@@ -30,7 +30,7 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
   override def phaseName: String = "extmethods"
 
   override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[ElimRepeated])
-  
+
   override def runsAfterGroupsOf = Set(classOf[FirstTransform]) // need companion objects to exist
 
   override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {

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

@@ -107,18 +107,18 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
      *  in `enclosure` or there is an intermediate class properly containing `enclosure`
      *  in which `sym` is also free. Also, update `liftedOwner` of `enclosure` so
      *  that `enclosure` can access `sym`, or its proxy in an intermediate class.
-     *  This means: 
-     *  
+     *  This means:
+     *
      *    1. If there is an intermediate class in which `sym` is free, `enclosure`
-     *       must be contained in that class (in order to access the `sym proxy stored 
+     *       must be contained in that class (in order to access the `sym proxy stored
      *       in the class).
-     *       
+     *
      *    2. If there is no intermediate class, `enclosure` must be contained
      *       in the class enclosing `sym`.
-     *       
+     *
      *  Return the closest enclosing intermediate class between `enclosure` and
      *  the owner of sym, or NoSymbol if none exists.
-     *  
+     *
      *  pre: sym.owner.isTerm, (enclosure.isMethod || enclosure.isClass)
      *
      *  The idea of `markFree` is illustrated with an example:
@@ -150,10 +150,10 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
       else {
         ctx.log(i"mark free: ${sym.showLocated} with owner ${sym.maybeOwner} marked free in $enclosure")
         ctx.debuglog(i"$enclosure != ${sym.enclosure}")
-        val intermediate = 
+        val intermediate =
           if (enclosure.is(PackageClass)) enclosure
-          else markFree(sym, enclosure.skipConstructor.enclosure) 
-            // `enclosure` might be a constructor, in which case we want the enclosure 
+          else markFree(sym, enclosure.skipConstructor.enclosure)
+            // `enclosure` might be a constructor, in which case we want the enclosure
             // of the enclosing class, so skipConstructor is needed here.
         if (intermediate.exists) {
           narrowLiftedOwner(enclosure, intermediate)
@@ -394,12 +394,12 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
       val sym = tree.symbol
       tree.tpe match {
         case tpe @ TermRef(prefix, _) =>
-          if (prefix eq NoPrefix) 
+          if (prefix eq NoPrefix)
             if (sym.enclosure != currentEnclosure && !sym.isStatic)
               (if (sym is Method) memberRef(sym) else proxyRef(sym)).withPos(tree.pos)
             else if (sym.owner.isClass) // sym was lifted out
               ref(sym).withPos(tree.pos)
-            else 
+            else
               tree
           else if (!prefixIsElidable(tpe)) ref(tpe)
           else tree

src/dotty/tools/dotc/transform/ParamForwarding.scala

@@ -21,7 +21,7 @@ import Contexts._, Types._, Symbols._, Flags._, TypeUtils._, DenotTransformers._
  */
 class ParamForwarding(thisTransformer: DenotTransformer) {
   import ast.tpd._
-  
+
   def forwardParamAccessors(impl: Template)(implicit ctx: Context): Template = {
     def fwd(stats: List[Tree])(implicit ctx: Context): List[Tree] = {
       val (superArgs, superParamNames) = impl.parents match {
@@ -68,4 +68,4 @@ class ParamForwarding(thisTransformer: DenotTransformer) {
 
     cpy.Template(impl)(body = fwd(impl.body)(ctx.withPhase(thisTransformer)))
   }
-}
+}

src/dotty/tools/dotc/transform/PostTyper.scala

@@ -16,26 +16,26 @@ import Decorators._
 import Symbols._, TypeUtils._
 
 /** A macro transform that runs immediately after typer and that performs the following functions:
- *  
+ *
  *  (1) Add super accessors and protected accessors (@see SuperAccessors)
- *  
+ *
  *  (2) Convert parameter fields that have the same name as a corresponding
  *      public parameter field in a superclass to a forwarder to the superclass
  *      field (corresponding = super class field is initialized with subclass field)
  *      (@see ForwardParamAccessors)
- *      
+ *
  *  (3) Add synthetic methods (@see SyntheticMethods)
- *      
+ *
  *  (4) Check that `New` nodes can be instantiated, and that annotations are valid
- *  
+ *
  *  (5) Convert all trees representing types to TypeTrees.
- *  
+ *
  *  (6) Check the bounds of AppliedTypeTrees
- *  
+ *
  *  (7) Insert `.package` for selections of package object members
- *  
+ *
  *  (8) Replaces self references by name with `this`
- *  
+ *
  *  The reason for making this a macro transform is that some functions (in particular
  *  super and protected accessors and instantiation checks) are naturally top-down and
  *  don't lend themselves to the bottom-up approach of a mini phase. The other two functions
@@ -54,16 +54,16 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
 
   protected def newTransformer(implicit ctx: Context): Transformer =
     new PostTyperTransformer
-    
+
   val superAcc = new SuperAccessors(thisTransformer)
   val paramFwd = new ParamForwarding(thisTransformer)
   val synthMth = new SyntheticMethods(thisTransformer)
-    
+
   private def newPart(tree: Tree): Option[New] = methPart(tree) match {
     case Select(nu: New, _) => Some(nu)
     case _ => None
   }
-  
+
   private def checkValidJavaAnnotation(annot: Tree)(implicit ctx: Context): Unit = {
     // TODO fill in
   }
@@ -79,28 +79,28 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
           tparam.info.asSeenFrom(tycon.tpe.normalizedPrefix, tparam.owner.owner).bounds)
         Checking.checkBounds(args, bounds, _.substDealias(tparams, _))
         norm(tree)
-      case _ => 
+      case _ =>
         norm(tree)
-    } 
+    }
   }
 
   class PostTyperTransformer extends Transformer {
-    
+
     private var inJavaAnnot: Boolean = false
-    
+
     private var parentNews: Set[New] = Set()
-    
+
     private def transformAnnot(annot: Tree)(implicit ctx: Context): Tree = {
       val saved = inJavaAnnot
       inJavaAnnot = annot.symbol is JavaDefined
       if (inJavaAnnot) checkValidJavaAnnotation(annot)
       try transform(annot)
       finally inJavaAnnot = saved
     }
-    
+
     private def transformAnnot(annot: Annotation)(implicit ctx: Context): Annotation =
       annot.derivedAnnotation(transformAnnot(annot.tree))
-    
+
     private def transformAnnots(tree: MemberDef)(implicit ctx: Context): Unit =
       tree.symbol.transformAnnotations(transformAnnot)
 
@@ -114,7 +114,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
           superAcc.transformSelect(super.transform(tree), targs)
       }
     }
-      
+
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       try normalizeTypeTree(tree) match {
         case tree: Ident =>
@@ -133,7 +133,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
         case tree: Template =>
           val saved = parentNews
           parentNews ++= tree.parents.flatMap(newPart)
-          try 
+          try
             synthMth.addSyntheticMethods(
               paramFwd.forwardParamAccessors(
                 superAcc.wrapTemplate(tree)(

src/dotty/tools/dotc/transform/SuperAccessors.scala

@@ -43,11 +43,11 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
      *  These are value class methods, which will become extension methods.
      *  (By-name arguments used to be included also, but these
      *  don't get a new class anymore, they are just wrapped in a new method).
-     *  
+     *
      *  These regions will have to be treated specially for the purpose
      *  of adding accessors. For instance, super calls from these regions
      *  always have to go through an accessor.
-     *  
+     *
      *  The `invalidOwner` field, if different from NoSymbol,
      *  contains the symbol that is not a valid owner.
      */
@@ -59,10 +59,10 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
       try trans
       finally invalidEnclClass = saved
     }
-    
-    private def validCurrentClass(implicit ctx: Context): Boolean = 
+
+    private def validCurrentClass(implicit ctx: Context): Boolean =
       ctx.owner.enclosingClass != invalidEnclClass
-        
+
     /** List buffers for new accessor definitions, indexed by class */
     private val accDefs = mutable.Map[Symbol, mutable.ListBuffer[Tree]]()
 
@@ -140,7 +140,7 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
       (sym eq Any_##)
     }
 
-    /** Replace `sel` (or `sel[targs]` if `targs` is nonempty) with a protected accessor 
+    /** Replace `sel` (or `sel[targs]` if `targs` is nonempty) with a protected accessor
      *  call, if necessary.
      */
     private def ensureProtectedAccessOK(sel: Select, targs: List[Tree])(implicit ctx: Context) = {
@@ -204,12 +204,12 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
       ctx.debuglog(s"Replaced $sel with $res")
       res
     }
-    
+
     def isProtectedAccessor(tree: Tree)(implicit ctx: Context): Boolean = tree match {
       case Apply(TypeApply(Select(_, name), _), qual :: Nil) => name.isProtectedAccessorName
       case _ => false
     }
-    
+
     /** Add a protected accessor, if needed, and return a tree that calls
      *  the accessor and returns the same member. The result is already
      *  typed.
@@ -225,8 +225,8 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
 
       // if the result type depends on the this type of an enclosing class, the accessor
       // has to take an object of exactly this type, otherwise it's more general
-      val receiverType = 
-        if (isThisType(sym.info.finalResultType)) clazz.thisType 
+      val receiverType =
+        if (isThisType(sym.info.finalResultType)) clazz.thisType
         else clazz.classInfo.selfType
       def accTypeOf(tpe: Type): Type = tpe match {
         case tpe: PolyType =>
@@ -401,10 +401,10 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
         val setter = protectedSetter(lhs)
         ctx.debuglog("Replaced " + tree + " with " + setter)
         setter.appliedTo(qual, rhs)
-      } 
-      else tree  
+      }
+      else tree
     }
-    
+
     /** Wrap template to template transform `op` with needed initialization and finalization */
     def wrapTemplate(tree: Template)(op: Template => Template)(implicit ctx: Context) = {
       accDefs(currentClass) = new mutable.ListBuffer[Tree]
@@ -417,7 +417,7 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
           case vd: ValOrDefDef => vd.symbol.flags is ParamAccessor
           case _ => false
         }
-        cpy.Template(impl)(body = params ++ accessors ++ rest)     
+        cpy.Template(impl)(body = params ++ accessors ++ rest)
       }
     }
 

src/dotty/tools/dotc/transform/SyntheticMethods.scala

@@ -31,18 +31,18 @@ import scala.language.postfixOps
  *    def equals(other: Any): Boolean
  *    def hashCode(): Int
  */
-class SyntheticMethods(thisTransformer: DenotTransformer) { 
+class SyntheticMethods(thisTransformer: DenotTransformer) {
   import ast.tpd._
 
   private var myValueSymbols: List[Symbol] = Nil
   private var myCaseSymbols: List[Symbol] = Nil
-  
+
   private def initSymbols(implicit ctx: Context) =
     if (myValueSymbols.isEmpty) {
       myValueSymbols = List(defn.Any_hashCode, defn.Any_equals)
       myCaseSymbols = myValueSymbols ++ List(defn.Any_toString, defn.Product_canEqual, defn.Product_productArity)
     }
-  
+
   def valueSymbols(implicit ctx: Context) = { initSymbols; myValueSymbols }
   def caseSymbols(implicit ctx: Context) = { initSymbols; myCaseSymbols }
 

src/dotty/tools/dotc/transform/TypeUtils.scala

@@ -26,7 +26,7 @@ class TypeUtils(val self: Type) extends AnyVal {
 
   def isPrimitiveValueType(implicit ctx: Context): Boolean =
     self.classSymbol.isPrimitiveValueClass
-    
+
   def ensureMethodic(implicit ctx: Context): Type = self match {
     case self: MethodicType => self
     case _ => ExprType(self)