Remove trailing spaces in Dotty tests.

17 files changed, 32 insertions, 32 deletions

diff --git a/tests/untried/neg-with-implicits/t7519-b/Mac_1.scala b/tests/untried/neg-with-implicits/t7519-b/Mac_1.scala
index 55b583d24..a9ecfd976 100644
--- a/tests/untried/neg-with-implicits/t7519-b/Mac_1.scala
+++ b/tests/untried/neg-with-implicits/t7519-b/Mac_1.scala
@@ -9,6 +9,6 @@ object IW {
 }
 object Mac {
   def mac(s: String): String = macro macImpl
-  def macImpl(c: Context)(s: c.Expr[String]): c.Expr[String] = 
+  def macImpl(c: Context)(s: c.Expr[String]): c.Expr[String] =
     c.universe.reify(IW.foo(s.splice))
 }
diff --git a/tests/untried/neg/literate_existentials.scala b/tests/untried/neg/literate_existentials.scala
index 8580347bf..fe47bd5fb 100644
--- a/tests/untried/neg/literate_existentials.scala
+++ b/tests/untried/neg/literate_existentials.scala
@@ -54,7 +54,7 @@ object LiterateExistentials {
 //  V1 <: Any
 //
 //  Which simplify to:
-//  V1 >: String <: Any 
+//  V1 >: String <: Any
 //
 //  That's not inconsistent, so we can say that:
 //  T <: U forSome { type X1 >: L1 <: H1 }
@@ -62,7 +62,7 @@ object LiterateExistentials {
 //  Nothing <: A forSome { type A >: String <: Any }
 
 // Now to ask the compiler:
-  
+
   implicitly[Nothing <:< (A forSome { type A >: String <: Any })]
 
 
@@ -85,15 +85,15 @@ object LiterateExistentials {
 //
 //  Which simplify to:
 //
-//  V1 >: lub(Int, String) <: Any 
+//  V1 >: lub(Int, String) <: Any
 //
-//  V1 >: Any <: Any 
+//  V1 >: Any <: Any
 //
 //  We have demonstrated consistency! We can say that:
 //    T :< (U forSome { type U >: L1 <: H1 })
 //  Under our bindings, this is:
 //    Int :< (M forSome { type M >: String <: Any })
-  
+
   implicitly[Int <:< (M forSome { type M >: String <: Any })]
 
 
@@ -179,7 +179,7 @@ object LiterateExistentials {
 //  Nothing <: V1
 //  V1 <: String
 //
-//  V1 >: Int <: String 
+//  V1 >: Int <: String
 //
 //  Alas! These are inconsistent! There is no supertype of Int that is a
 //  subtype of String! Our substitution rule does not allow us to claim that our
diff --git a/tests/untried/neg/t0764.scala b/tests/untried/neg/t0764.scala
index 7ee76feab..0c3f857a8 100644
--- a/tests/untried/neg/t0764.scala
+++ b/tests/untried/neg/t0764.scala
@@ -29,7 +29,7 @@ _1.type <:< Node{type T = NextType} (because skolemization and _1's upper bound)
 Node{type T = NextType} <:< _1.type forSome val _1: Node{type T = NextType}
 because:
 Node{type T = NextType} <:< T forSome {type T <: Node{type T = NextType} with Singleton}
-because 
+because
 Node{type T = NextType} <:< Node{type T = NextType} with Singleton
 
 hmmm.. might the with Singleton be throwing a wrench in our existential house?
diff --git a/tests/untried/neg/t2066b.scala b/tests/untried/neg/t2066b.scala
index aebf761fc..b309a48d6 100644
--- a/tests/untried/neg/t2066b.scala
+++ b/tests/untried/neg/t2066b.scala
@@ -11,6 +11,6 @@ object Test extends App {
 
     val p = new P(1)
     val palias = (new B():A).f[P](p)
-    palias.y = "hello"  
+    palias.y = "hello"
     val z: Int = p.y
 }
diff --git a/tests/untried/neg/t7872.scala b/tests/untried/neg/t7872.scala
index 66d22a071..55480be6a 100644
--- a/tests/untried/neg/t7872.scala
+++ b/tests/untried/neg/t7872.scala
@@ -1,7 +1,7 @@
 trait Cov[+A]
 trait Inv[-A]
 
-object varianceExploit {  
+object varianceExploit {
   type l[-a] = Cov[a]
   type x = {type l[-a] = Cov[a]}
   def foo[M[_]] = ()
diff --git a/tests/untried/neg/t7872b.scala b/tests/untried/neg/t7872b.scala
index 307a1470c..e76145cce 100644
--- a/tests/untried/neg/t7872b.scala
+++ b/tests/untried/neg/t7872b.scala
@@ -1,20 +1,20 @@
 object coinv {
   def up[F[+_]](fa: F[String]): F[Object] = fa
   def down[F[-_]](fa: F[Object]): F[String] = fa
- 
+
   up(List("hi"))
- 
+
   // should not compile; `l' is unsound
   def oops1 = down[({type l[-a] = List[a]})#l](List('whatever: Object)).head + "oops"
   // scala> oops1
   // java.lang.ClassCastException: scala.Symbol cannot be cast to java.lang.String
   //         at com.nocandysw.coinv$.oops1(coinv.scala:12)
- 
+
   type Stringer[-A] = A => String
   down[Stringer](_.toString)
   // [error] type A is contravariant, but type _ is declared covariant
   // up[Stringer]("printed: " + _)
- 
+
   // should not compile; `l' is unsound
   def oops2 = up[({type l[+a] = Stringer[a]})#l]("printed: " + _)
   // scala> oops2(Some(33))
diff --git a/tests/untried/neg/t7872c.scala b/tests/untried/neg/t7872c.scala
index fa12a523b..112248bc8 100644
--- a/tests/untried/neg/t7872c.scala
+++ b/tests/untried/neg/t7872c.scala
@@ -1,7 +1,7 @@
 object coinv {
   def up[F[+_]](fa: F[String]): F[Object] = fa
   def down[F[-_]](fa: F[Object]): F[String] = fa
- 
+
   up(List("hi"))
   // [error] type A is covariant, but type _ is declared contravariant
   down(List('whatever: Object))
diff --git a/tests/untried/pos/SI-4012-a.scala b/tests/untried/pos/SI-4012-a.scala
index 7fceeea3c..8ce8e5691 100644
--- a/tests/untried/pos/SI-4012-a.scala
+++ b/tests/untried/pos/SI-4012-a.scala
@@ -4,4 +4,4 @@ trait C1[+A] {
 trait C2[@specialized +A] extends C1[A] {
   override def head: A = super.head
 }
-class C3 extends C2[Char] 
+class C3 extends C2[Char]
diff --git a/tests/untried/pos/SI-4012-b.scala b/tests/untried/pos/SI-4012-b.scala
index 6bc859276..102019463 100644
--- a/tests/untried/pos/SI-4012-b.scala
+++ b/tests/untried/pos/SI-4012-b.scala
@@ -3,13 +3,13 @@ trait Super[@specialized(Int) A] {
 }
 
 object Sub extends Super[Int] {
-  // it is expected that super[Super].superb crashes, since 
+  // it is expected that super[Super].superb crashes, since
   // specialization does parent class rewiring, and the super
   // of Sub becomes Super$mcII$sp and not Super. But I consider
   // this normal behavior -- if you want, I can modify duplicatiors
   // to make this work, but I consider it's best to keep this
   // let the user know Super is not the superclass anymore.
   // super[Super].superb - Vlad
-  super.superb        // okay    
+  super.superb        // okay
   override def superb: Int = super.superb // okay
 }
diff --git a/tests/untried/pos/t8046.scala b/tests/untried/pos/t8046.scala
index 304d70b6b..9beb0b9d1 100644
--- a/tests/untried/pos/t8046.scala
+++ b/tests/untried/pos/t8046.scala
@@ -2,13 +2,13 @@ trait One {
   type Op[A]
   type Alias[A] = Op[A]
 }
- 
+
 trait Two extends One {
   trait Op[A] extends (A => A)
- 
+
   // This compiles
   class View1 extends Op[Int] { def apply(xs: Int) = xs }
- 
+
   // ??? base class View2 not found in basetypes of class View2
   // ./a.scala:9: error: class View2 needs to be abstract, since \
   //   method apply in trait Function1 of type (v1: T1)R is not defined
diff --git a/tests/untried/pos/t8046b.scala b/tests/untried/pos/t8046b.scala
index 45b99fd7e..99d06b7e0 100644
--- a/tests/untried/pos/t8046b.scala
+++ b/tests/untried/pos/t8046b.scala
@@ -2,14 +2,14 @@ trait One {
   type Op[A]
   type Alias = Op[Int]
 }
- 
+
 trait Two extends One {
   trait Op[A] extends M[A]
   //(a: Alias) => a.value.toChar               // okay
                                              // (=> A).asSeenFrom(a.type, trait M): => Int
   class View2 extends Alias { value.toChar } // toChar is not a member of type parameter A
                                              // (=> A).asSeenFrom(View2.this.type, trait M): => A
-  
+
   // override type Alias = Op[Int]           // works with this
 }
 
diff --git a/tests/untried/pos/t8060.scala b/tests/untried/pos/t8060.scala
index 90e014d74..24881b60e 100644
--- a/tests/untried/pos/t8060.scala
+++ b/tests/untried/pos/t8060.scala
@@ -1,10 +1,10 @@
 trait M[F[_]]
- 
+
 trait P[A] {
   type CC[X] = P[X]
   def f(p: A => Boolean): M[CC]
 }
- 
+
 trait Other {
   // was infinite loop trying to dealias `x$1.CC`
   def g[A](p: A => Boolean): P[A] => M[P] = _ f p
diff --git a/tests/untried/pos/t8170.scala b/tests/untried/pos/t8170.scala
index 1991da72f..fe9f262ba 100644
--- a/tests/untried/pos/t8170.scala
+++ b/tests/untried/pos/t8170.scala
@@ -22,6 +22,6 @@ this = {AliasArgsTypeRef@3004}"Test#7680.a#14899.T#14823[O#7702.X#7793]"
     info = namer: [F#14824 <: O#7703.X#7793]F#14824
 result = {AbstractNoArgsTypeRef@3237}"F#24451"
 tp = {PolyType@3235}"[F#14824 <: O#7703.X#7793]F#14824"
-tparams = 
+tparams =
   (0)  = {AbstractTypeSymbol@3247}"type F#24451"
 */
diff --git a/tests/untried/pos/t8170b.scala b/tests/untried/pos/t8170b.scala
index 53036f6c8..e3d1d33d9 100644
--- a/tests/untried/pos/t8170b.scala
+++ b/tests/untried/pos/t8170b.scala
@@ -13,13 +13,13 @@ object ScalaZeee {
      type Folded[N[X] >: M[X], U, F <: HFold[N, U]] <: U
   }
 }
- 
+
 object TypelevelUsage {
   import ScalaZeee._
   type T = GenericCons[Some, String, KNil.type]
   val klist1: T = ???
   type T2 = klist1.Folded[Option, Int, HFold[Option, Int]]
   val count2: T2 = ???
-   
+
   count2.ensuring(x => true).toChar // trigger an implicit search
 }
diff --git a/tests/untried/pos/t8315.scala b/tests/untried/pos/t8315.scala
index 2f7742ed6..f56cfda7a 100644
--- a/tests/untried/pos/t8315.scala
+++ b/tests/untried/pos/t8315.scala
@@ -2,11 +2,11 @@ object Test {
   def crash(as: Listt): Unit = {
     map(as, (_: Any) => return)
   }
- 
+
   final def map(x: Listt, f: Any => Any): Any = {
     if (x eq Nill) "" else f("")
   }
 }
- 
+
 object Nill extends Listt
 class Listt
diff --git a/tests/untried/pos/t8363.scala b/tests/untried/pos/t8363.scala
index 639faf412..aecb8e4dc 100644
--- a/tests/untried/pos/t8363.scala
+++ b/tests/untried/pos/t8363.scala
@@ -1,5 +1,5 @@
 class C(a: Any)
-class Test {  
+class Test {
   def foo: Any = {
     def form = 0
     class C1 extends C(() => form)
diff --git a/tests/untried/pos/t8376/Test.scala b/tests/untried/pos/t8376/Test.scala
index ba078a353..9440d76fa 100644
--- a/tests/untried/pos/t8376/Test.scala
+++ b/tests/untried/pos/t8376/Test.scala
@@ -5,6 +5,6 @@ class Test {
 }
 
 object BindingsY {
-  def select1(root: String, steps: String*) = ()  
+  def select1(root: String, steps: String*) = ()
   def select1(root: Any, steps: String*) = ()
 }