Rename This types in tests

Author: odersky

tests/disabled/partest/run/existentials-in-compiler.check

@@ -4,8 +4,8 @@ abstract trait Bippy[A <: AnyRef, B] extends AnyRef
 abstract trait BippyBud[A <: AnyRef, B, C <: List[A]] extends AnyRef
     extest.BippyBud[A,B,C] forSome { A <: AnyRef; B; C <: List[A] }
 
-abstract trait BippyLike[A <: AnyRef, B <: List[A], This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends AnyRef
-    extest.BippyLike[A,B,This] forSome { A <: AnyRef; B <: List[A]; This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B] }
+abstract trait BippyLike[A <: AnyRef, B <: List[A], Self <: extest.BippyLike[A,B,Self] with extest.Bippy[A,B]] extends AnyRef
+    extest.BippyLike[A,B,Self] forSome { A <: AnyRef; B <: List[A]; Self <: extest.BippyLike[A,B,Self] with extest.Bippy[A,B] }
 
 abstract trait Contra[-A >: AnyRef, -B] extends AnyRef
     extest.Contra[AnyRef, _]
@@ -151,6 +151,6 @@ abstract trait Cov49[-A >: Null, -B] extends AnyRef
 abstract trait Covariant[+A <: AnyRef, +B] extends AnyRef
     extest.Covariant[AnyRef,Any]
 
-abstract trait CovariantLike[+A <: AnyRef, +B <: List[A], +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends AnyRef
-    extest.CovariantLike[A,B,This] forSome { +A <: AnyRef; +B <: List[A]; +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B] }
+abstract trait CovariantLike[+A <: AnyRef, +B <: List[A], +Self <: extest.CovariantLike[A,B,Self] with extest.Covariant[A,B]] extends AnyRef
+    extest.CovariantLike[A,B,Self] forSome { +A <: AnyRef; +B <: List[A]; +Self <: extest.CovariantLike[A,B,Self] with extest.Covariant[A,B] }
 

tests/disabled/partest/run/existentials-in-compiler.scala

@@ -13,7 +13,7 @@ object Test extends CompilerTest {
   override def code = """
 package extest {
   trait Bippy[A <: AnyRef, B] { }     // wildcards
-  trait BippyLike[A <: AnyRef, B <: List[A], This <: BippyLike[A, B, This] with Bippy[A, B]]  // no wildcards
+  trait BippyLike[A <: AnyRef, B <: List[A], Self <: BippyLike[A, B, Self] with Bippy[A, B]]  // no wildcards
   trait BippyBud[A <: AnyRef, B, C <: List[A]]
 
   trait Cov01[+A <: AnyRef, +B] { }
@@ -67,7 +67,7 @@ package extest {
   trait Cov49[-A >: Null, -B] { }
 
   trait Covariant[+A <: AnyRef, +B] { }
-  trait CovariantLike[+A <: AnyRef, +B <: List[A], +This <: CovariantLike[A, B, This] with Covariant[A, B]]
+  trait CovariantLike[+A <: AnyRef, +B <: List[A], +Self <: CovariantLike[A, B, Self] with Covariant[A, B]]
 
   trait Contra[-A >: AnyRef, -B] { }
   trait ContraLike[-A >: AnyRef, -B >: List[A]]

tests/invalid/pos/IterableSelfRec.scala

@@ -5,27 +5,27 @@ package immutable
 import annotation.unchecked.uncheckedVariance
 
 trait Collection[T] { self =>
-  type This <: Collection { type This <: self.This }
-  def companion: CollectionCompanion[This]
+  type ThisCollection <: Collection { type ThisCollection <: self.ThisCollection }
+  def companion: CollectionCompanion[ThisCollection]
 }
 
 trait Iterable[T] extends Collection[T] { self =>
-  type This <: Iterable { type This <: self.This }
-  override def companion: IterableCompanion[This] = Iterable.asInstanceOf
+  type ThisCollection <: Iterable { type ThisCollection <: self.ThisCollection }
+  override def companion: IterableCompanion[ThisCollection] = Iterable.asInstanceOf
 
   def iterator: Iterator[T]
 }
 
 trait Seq[T] extends Iterable[T] { self =>
-  type This <: Seq { type This <: self.This }
-  override def companion: IterableCompanion[This] = Seq.asInstanceOf
+  type ThisCollection <: Seq { type ThisCollection <: self.ThisCollection }
+  override def companion: IterableCompanion[ThisCollection] = Seq.asInstanceOf
 
   def apply(x: Int): T
 }
 
-abstract class CollectionCompanion[+CC[X] <: Collection[X] { type This <: CC }]
+abstract class CollectionCompanion[+CC[X] <: Collection[X] { type ThisCollection <: CC }]
 
-abstract class IterableCompanion[+CC[X] <: Iterable[X] { type This <: CC }] extends CollectionCompanion[CC] {
+abstract class IterableCompanion[+CC[X] <: Iterable[X] { type ThisCollection <: CC }] extends CollectionCompanion[CC] {
   def fromIterator[T](it: Iterator[T]): CC[T]
   def map[T, U](xs: Iterable[T], f: T => U): CC[U] =
     fromIterator(xs.iterator.map(f))
@@ -37,7 +37,7 @@ abstract class IterableCompanion[+CC[X] <: Iterable[X] { type This <: CC }] exte
   implicit def transformOps[T](xs: CC[T] @uncheckedVariance): TransformOps[CC, T] = ??? // new TransformOps[CC, T](xs)
 }
 
-class TransformOps[+CC[X] <: Iterable[X] { type This <: CC }, T] (val xs: CC[T]) extends AnyVal {
+class TransformOps[+CC[X] <: Iterable[X] { type ThisCollection <: CC }, T] (val xs: CC[T]) extends AnyVal {
   def companion[T](xs: CC[T] @uncheckedVariance): IterableCompanion[CC] = xs.companion
   def map[U](f: T => U): CC[U] = companion(xs).map(xs, f)
   def filter(p: T => Boolean): CC[T] = companion(xs).filter(xs, p)

tests/neg/typeclass-encoding2.scala

@@ -6,21 +6,21 @@ object runtime1 {
 
   trait TypeClass1[A] {
     val common: TypeClassCommon1
-    type This[X] = common.This[X]
+    type ThisClass[X] = common.ThisClass[X]
   }
 
   trait TypeClassCommon1 { self =>
-    type This[X]
+    type ThisClass[X]
     type Instance[X] <: TypeClass1[X]
-    def inject[A](x: This[A]): Instance[A]// { val common: self.type }
+    def inject[A](x: ThisClass[A]): Instance[A]// { val common: self.type }
   }
 
   trait Extension1[From[_], To[X] <: TypeClass1[X]] extends TypeClassCommon1 {
-    type This[X] = From[X]
+    type ThisClass[X] = From[X]
     type Instance[X] = To[X]
   }
 
   implicit def inject[A, From[_]](x: From[A])
-      (implicit ev: Extension1[From, _]): ev.Instance[A] { type This[X] = From[X] } =
-    ev.inject(x) // error: found: ev.To[A], required: ev.To[A]{This = From}
+      (implicit ev: Extension1[From, _]): ev.Instance[A] { type ThisClass[X] = From[X] } =
+    ev.inject(x) // error: found: ev.To[A], required: ev.To[A]{ThisClass = From}
 }

tests/pending/pos/depmet_implicit_oopsla_session.scala

@@ -1,8 +1,8 @@
 object Sessions {
-  trait Session[This] {
+  trait Session[Self] {
     type Dual
-    type HasDual[D] = Session[This]{type Dual=D}
-    def run(p: This, dp: Dual): Unit
+    type HasDual[D] = Session[Self]{type Dual=D}
+    def run(p: Self, dp: Dual): Unit
   }
 
   implicit object StopSession extends Session[Stop] {

tests/pos-with-compiler/tasty/definitions.scala

@@ -68,7 +68,7 @@ object definitions {
     case Ident(name: String, override val tpe: Type)
     case Select(prefix: Term, name: String, signature: Option[Signature])
     case Literal(value: Constant)
-    case This(id: Option[Id])
+    case Self(id: Option[Id])
     case New(tpt: TypeTree)
     case Throw(expr: Term)
     case NamedArg(name: String, arg: Term)
@@ -163,8 +163,8 @@ object definitions {
       }
     }
 
-    abstract class LambdaType[ParamInfo, This <: LambdaType[ParamInfo, This]](
-      val companion: LambdaTypeCompanion[ParamInfo, This]
+    abstract class LambdaType[ParamInfo, Self <: LambdaType[ParamInfo, Self]](
+      val companion: LambdaTypeCompanion[ParamInfo, Self]
     ) extends Type {
       private[Type] var _pinfos: List[ParamInfo]
       private[Type] var _restpe: Type
@@ -174,10 +174,10 @@ object definitions {
       def resultType: Type = _restpe
     }
 
-    abstract class LambdaTypeCompanion[ParamInfo, This <: LambdaType[ParamInfo, This]] {
-      def apply(pnames: List[String], ptypes: List[ParamInfo], restpe: Type): This
+    abstract class LambdaTypeCompanion[ParamInfo, Self <: LambdaType[ParamInfo, Self]] {
+      def apply(pnames: List[String], ptypes: List[ParamInfo], restpe: Type): Self
 
-      def apply(pnames: List[String], ptypesExp: This => List[ParamInfo], restpeExp: This => Type): This = {
+      def apply(pnames: List[String], ptypesExp: Self => List[ParamInfo], restpeExp: Self => Type): Self = {
         val lambda = apply(pnames, Nil, PlaceHolder)
         lambda._pinfos = ptypesExp(lambda)
         lambda._restpe = restpeExp(lambda)

tests/pos/extmethods-2.scala

@@ -1,7 +1,7 @@
 package extMethods
 
 trait That1[A]
-class T[A, This <: That1[A]](val x: Int) extends AnyVal {
-  self: This =>
-  final def loop(x: This, cnt: Int): Int = loop(x, cnt + 1)
+class T[A, Self <: That1[A]](val x: Int) extends AnyVal {
+  self: Self =>
+  final def loop(x: Self, cnt: Int): Int = loop(x, cnt + 1)
 }

tests/pos/extmethods.scala

@@ -1,7 +1,7 @@
 trait That1[A]
-class T[A, This <: That1[A]](val x: Int) extends AnyVal {
-  self: This =>
-  final def loop(x: This, cnt: Int): Int = loop(x, cnt + 1)
+class T[A, Self <: That1[A]](val x: Int) extends AnyVal {
+  self: Self =>
+  final def loop(x: Self, cnt: Int): Int = loop(x, cnt + 1)
   def const[B](): Boolean = return true
 }
 

tests/pos/i1401.scala

@@ -4,19 +4,19 @@ trait Subtractable[AS, +Repr <: Subtractable[AS, Repr]] {
   def -(elem: AS): Repr
 }
 
-trait BufferLike[BA, +This <: BufferLike[BA, This] with Buffer[BA]]
-                extends Subtractable[BA, This]
-{ self : This =>
+trait BufferLike[BA, +Self <: BufferLike[BA, Self] with Buffer[BA]]
+                extends Subtractable[BA, Self]
+{ self : Self =>
 
   /* Without fix-#1401:
    *
-     error: overriding method - in trait Subtractable of type (elem: A)This & i1401.Buffer[A];
-     method - of type (elem: BA)This has incompatible type
-     def -(elem: BA): This
+     error: overriding method - in trait Subtractable of type (elem: A)Self & i1401.Buffer[A];
+     method - of type (elem: BA)Self has incompatible type
+     def -(elem: BA): Self
          ^
      one error found
   */
-  def -(elem: BA): This
+  def -(elem: BA): Self
 }
 
 trait Buffer[A] extends BufferLike[A, Buffer[A]]

tests/pos/i4884.scala

@@ -14,7 +14,7 @@ object Test {
   }
   trait TestConstructor4[D] {
     trait TestConstructor5[E] {
-      trait MSetLike[X <: D & E, This <: MSet[X] with MSetLike[X, This]]
+      trait MSetLike[X <: D & E, Self <: MSet[X] with MSetLike[X, Self]]
       trait MSet[X <: D & E] extends MSetLike[X, MSet[X]]
     }
   }

tests/pos/pets.scala

@@ -1,21 +1,21 @@
 // Representing the current type
 trait Pet {
-  type This <: Pet
+  type ThisPet <: Pet
   def name: String
-  def renamed(newName: String): This
+  def renamed(newName: String): ThisPet
 }
 
 case class Fish(name: String, age: Int) extends Pet {
-  type This = Fish
+  type ThisPet = Fish
   def renamed(newName: String): Fish = copy(name = newName)
 }
 
 case class Kitty(name: String, age: Int) extends Pet {
-  type This = Kitty
+  type ThisPet = Kitty
   def renamed(newName: String): Kitty = copy(name = newName)
 }
 
 object Test {
-  def esquire[A <: Pet](a: A): a.This = a.renamed(a.name + ", Esq.")
+  def esquire[A <: Pet](a: A): a.ThisPet = a.renamed(a.name + ", Esq.")
   val f: Fish = esquire(new Fish("bob", 22))
 }

tests/pos/spec-partialmap.scala

@@ -8,5 +8,5 @@ trait PartialMap[@specialized A,@specialized B] extends PartialFunction[A,B] wit
     for ((k,v) <- iterator; if f(k)) yield v
 
   // if this is commented, it compiles fine:
-  def apply[This <: Iterable[A]](keys : IterableOps[A, Iterable, This]): Iterable[B] = keys.map(apply)
+  def apply[Self <: Iterable[A]](keys : IterableOps[A, Iterable, Self]): Iterable[B] = keys.map(apply)
 }

tests/pos/t0039.scala

@@ -1,5 +1,5 @@
-abstract class Extensible[A, This <: Extensible[A, This]](x: A, xs: This) { self: This =>
-    def mkObj(x: A, xs: This): This;
+abstract class Extensible[A, Self <: Extensible[A, Self]](x: A, xs: Self) { self: Self =>
+    def mkObj(x: A, xs: Self): Self;
 }
 class Fixed[A](x: A, xs: Fixed[A]) extends Extensible[A, Fixed[A]](x, xs) {
     def mkObj(x: A, xs: Fixed[A]) = new Fixed(x, xs);

tests/pos/t2399.scala

@@ -1,14 +1,14 @@
 trait That1[A]
 trait That2[A, R <: That2[A, R]]
 
-trait T[A, This >: Null <: That1[A] with T[A, This]] extends That2[A, This] {
-  self: This =>
+trait T[A, Self >: Null <: That1[A] with T[A, Self]] extends That2[A, Self] {
+  self: Self =>
 
-  private var next: This = _
+  private var next: Self = _
   def isEmpty = next eq null
 
   def length: Int = {
-    def loop(x: This, cnt: Int): Int = if (x.isEmpty) cnt else loop(x.next, cnt + 1)
+    def loop(x: Self, cnt: Int): Int = if (x.isEmpty) cnt else loop(x.next, cnt + 1)
     loop(self, 0)
   }
 }

tests/pos/t4243.scala

@@ -4,13 +4,13 @@
 
 object wrap {
 
-  trait DomainLike[@specialized(Int) A, +This <: Domain[A]]
+  trait DomainLike[@specialized(Int) A, +Self <: Domain[A]]
 
   trait Domain[@specialized(Int) B]
   extends DomainLike[B, Domain[B]]
 
-  trait IterableDomainLike[@specialized(Int) C, +This <: IterableDomain[C]]
-  extends DomainLike[C, This]
+  trait IterableDomainLike[@specialized(Int) C, +Self <: IterableDomain[C]]
+  extends DomainLike[C, Self]
 
   trait IterableDomain[@specialized(Int) D]
   extends Domain[D] with IterableDomainLike[D, IterableDomain[D]]

tests/pos/typeclass-encoding.scala

@@ -25,14 +25,14 @@
 object runtime {
 
   trait TypeClass {
-    type This
-    type StaticPart[This]
+    type ThisClass
+    type StaticPart[ThisClass]
   }
 
   trait Implementation[From] {
-    type This = From
+    type ThisClass = From
     type Implemented <: TypeClass
-    def inject(x: From): Implemented { type This = From }
+    def inject(x: From): Implemented { type ThisClass = From }
   }
 
   class CompanionOf[T] { type StaticPart[_] }
@@ -43,21 +43,21 @@ object runtime {
     ev1.asInstanceOf  // can we avoid the cast?
 
   implicit def inject[From](x: From)(
-      implicit ev1: Implementation[From]): ev1.Implemented { type This = From } =
+      implicit ev1: Implementation[From]): ev1.Implemented { type ThisClass = From } =
     ev1.inject(x)
 }
 
 object semiGroups {
   import runtime._
 
   trait SemiGroup extends TypeClass {
-    def add(that: This): This
+    def add(that: ThisClass): ThisClass
   }
 
   trait Monoid extends SemiGroup {
-    type StaticPart[This] <: MonoidStatic[This]
+    type StaticPart[ThisClass] <: MonoidStatic[ThisClass]
   }
-  abstract class MonoidStatic[This] { def unit: This }
+  abstract class MonoidStatic[ThisClass] { def unit: ThisClass }
 
   implicit def companionOfMonoid: CompanionOf[Monoid] {
     type StaticPart[X] = MonoidStatic[X]
@@ -69,18 +69,18 @@ object semiGroups {
     type Implemented = Monoid
     def unit: Int = 0
     def inject($this: Int) = new Monoid {
-      type This = Int
-      def add(that: This): This = $this + that
+      type ThisClass = Int
+      def add(that: ThisClass): ThisClass = $this + that
     }
   }
 
   implicit object extend_String_Monoid extends MonoidStatic[String], Implementation[String] {
     type Implemented = Monoid
     def unit = ""
-    def inject($this: String): Monoid { type This = String } =
+    def inject($this: String): Monoid { type ThisClass = String } =
       new Monoid {
-        type This = String
-        def add(that: This): This = $this ++ that
+        type ThisClass = String
+        def add(that: ThisClass): ThisClass = $this ++ that
       }
   }