Rename This types in library and tests

Author: odersky

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

@@ -1328,7 +1328,7 @@ object SymDenotations {
     /** The type parameters of a class symbol, Nil for all other symbols */
     def typeParams(implicit ctx: Context): List[TypeSymbol] = Nil
 
-    /** The type This(cls), where cls is this class, NoPrefix for all other symbols */
+    /** The type ThisType(cls), where cls is this class, NoPrefix for all other symbols */
     def thisType(implicit ctx: Context): Type = NoPrefix
 
     def typeRef(implicit ctx: Context): TypeRef =

compiler/src/dotty/tools/dotc/util/WeakHashSet.scala

@@ -23,7 +23,7 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
 
   def this() = this(initialCapacity = WeakHashSet.defaultInitialCapacity, loadFactor = WeakHashSet.defaultLoadFactor)
 
-  type This = WeakHashSet[A]
+  type ThisType = WeakHashSet[A]
 
   /**
    * queue of Entries that hold elements scheduled for GC
@@ -252,7 +252,7 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
   }
 
   // true if this set is empty
-  override def empty: This = new WeakHashSet[A](initialCapacity, loadFactor)
+  override def empty: ThisType = new WeakHashSet[A](initialCapacity, loadFactor)
 
   // the number of elements in this set
   override def size: Int = {

compiler/test/dotty/tools/dotc/parsing/parsePackage.scala

@@ -19,8 +19,8 @@ object parsePackage extends ParserTest {
       tree match {
         case Ident(name) =>
           Ident(name)
-        case This(name) =>
-          This(name)
+        case ThisRef(name) =>
+          ThisRef(name)
         case TypedSplice(t) =>
           TypedSplice(t)
         case SymbolLit(str) =>

library/src-bootstrapped/scala/tasty/reflect/TreeUtils.scala

@@ -21,7 +21,7 @@ trait TreeUtils
           x
         case Select(qualifier, _) =>
           foldTree(x, qualifier)
-        case This(qual) =>
+        case ThisRef(qual) =>
           x
         case Super(qual, _) =>
           foldTree(x, qual)
@@ -163,7 +163,7 @@ trait TreeUtils
           tree
         case Select(qualifier, name) =>
           Select.copy(tree)(transformTerm(qualifier), name)
-        case This(qual) =>
+        case ThisRef(qual) =>
           tree
         case Super(qual, mix) =>
           Super.copy(tree)(transformTerm(qual), mix)

library/src/scala/Tuple.scala

@@ -20,17 +20,17 @@ sealed trait Tuple extends Any {
   /** Return a new tuple by prepending the element to `this` tuple.
    *  This opteration is O(this.size)
    */
-  inline def *: [H, This >: this.type <: Tuple] (x: H): H *: This =
-    DynamicTuple.dynamicCons[H, This](x, this)
+  inline def *: [H, Self >: this.type <: Tuple] (x: H): H *: Self =
+    DynamicTuple.dynamicCons[H, Self](x, this)
 
   /** Return a new tuple by concatenating `this` tuple with `that` tuple.
    *  This opteration is O(this.size + that.size)
    */
-  inline def ++ [This >: this.type <: Tuple](that: Tuple): Concat[This, that.type] =
-    DynamicTuple.dynamicConcat[This, that.type](this, that)
+  inline def ++ [Self >: this.type <: Tuple](that: Tuple): Concat[Self, that.type] =
+    DynamicTuple.dynamicConcat[Self, that.type](this, that)
 
   /** Return the size (or arity) of the tuple */
-  inline def size[This >: this.type <: Tuple]: Size[This] =
+  inline def size[Self >: this.type <: Tuple]: Size[Self] =
     DynamicTuple.dynamicSize(this)
 
   /** Given two tuples, `(a1, ..., an)` and `(a1, ..., an)`, returns a tuple
@@ -40,7 +40,7 @@ sealed trait Tuple extends Any {
    *  tuple types has a `Unit` tail. Otherwise the result type is
    *  `(A1, B1) *: ... *: (Ai, Bi) *: Tuple`
    */
-  inline def zip[This >: this.type <: Tuple, T2 <: Tuple](t2: T2): Zip[This, T2] =
+  inline def zip[Self >: this.type <: Tuple, T2 <: Tuple](t2: T2): Zip[Self, T2] =
     DynamicTuple.dynamicZip(this, t2)
 
  /** Called on a tuple `(a1, ..., an)`, returns a new tuple `(f(a1), ..., f(an))`.
@@ -151,18 +151,18 @@ sealed trait NonEmptyTuple extends Tuple {
   /** Get the i-th element of this tuple.
    *  Equivalent to productElement but with a precise return type.
    */
-  inline def apply[This >: this.type <: NonEmptyTuple](n: Int): Elem[This, n.type] =
-    DynamicTuple.dynamicApply[This, n.type](this, n)
+  inline def apply[Self >: this.type <: NonEmptyTuple](n: Int): Elem[Self, n.type] =
+    DynamicTuple.dynamicApply[Self, n.type](this, n)
 
   /** Get the head of this tuple */
-  inline def head[This >: this.type <: NonEmptyTuple]: Head[This] =
-    DynamicTuple.dynamicApply[This, 0](this, 0)
+  inline def head[Self >: this.type <: NonEmptyTuple]: Head[Self] =
+    DynamicTuple.dynamicApply[Self, 0](this, 0)
 
   /** Get the tail of this tuple.
    *  This opteration is O(this.size)
    */
-  inline def tail[This >: this.type <: NonEmptyTuple]: Tail[This] =
-    DynamicTuple.dynamicTail[This](this)
+  inline def tail[Self >: this.type <: NonEmptyTuple]: Tail[Self] =
+    DynamicTuple.dynamicTail[Self](this)
 
 }
 

library/src/scala/runtime/DynamicTuple.scala

@@ -192,8 +192,8 @@ object DynamicTuple {
     arr
   }
 
-  def dynamicCons[H, This <: Tuple](x: H, self: Tuple): H *: This = {
-    type Result = H *: This
+  def dynamicCons[H, Self <: Tuple](x: H, self: Tuple): H *: Self = {
+    type Result = H *: Self
     (self: Any) match {
       case () =>
         Tuple1(x).asInstanceOf[Result]
@@ -210,8 +210,8 @@ object DynamicTuple {
     }
   }
 
-  def dynamicConcat[This <: Tuple, That <: Tuple](self: This, that: That): Concat[This, That] = {
-    type Result = Concat[This, That]
+  def dynamicConcat[Self <: Tuple, That <: Tuple](self: Self, that: That): Concat[Self, That] = {
+    type Result = Concat[Self, That]
     (this: Any) match {
       case self: Unit => return self.asInstanceOf[Result]
       case _ =>
@@ -223,13 +223,13 @@ object DynamicTuple {
     dynamicFromArray[Result](dynamicToArray(self) ++ dynamicToArray(that))
   }
 
-  def dynamicSize[This <: Tuple](self: This): Size[This] = (self: Any) match {
-    case self: Unit => 0.asInstanceOf[Size[This]]
-    case self: Product => self.productArity.asInstanceOf[Size[This]]
+  def dynamicSize[Self <: Tuple](self: Self): Size[Self] = (self: Any) match {
+    case self: Unit => 0.asInstanceOf[Size[Self]]
+    case self: Product => self.productArity.asInstanceOf[Size[Self]]
   }
 
-  def dynamicTail[This <: NonEmptyTuple] (self: This): Tail[This] = {
-    type Result = Tail[This]
+  def dynamicTail[Self <: NonEmptyTuple] (self: Self): Tail[Self] = {
+    type Result = Tail[Self]
     val res = (self: Any) match {
       case self: Tuple1[_] => ()
       case self: Tuple2[_, _] => Tuple1(self._2)
@@ -240,26 +240,26 @@ object DynamicTuple {
     res.asInstanceOf[Result]
   }
 
-  def dynamicApply[This <: NonEmptyTuple, N <: Int] (self: This, n: Int): Elem[This, N] = {
-    type Result = Elem[This, N]
+  def dynamicApply[Self <: NonEmptyTuple, N <: Int] (self: Self, n: Int): Elem[Self, N] = {
+    type Result = Elem[Self, N]
     val res = (self: Any) match {
       case self: Unit => throw new IndexOutOfBoundsException(n.toString)
       case self: Product => self.productElement(n)
     }
     res.asInstanceOf[Result]
   }
 
-  def dynamicZip[This <: Tuple, T2 <: Tuple](t1: This, t2: T2): Zip[This, T2] = {
-    if (t1.size == 0 || t2.size == 0) ().asInstanceOf[Zip[This, T2]]
+  def dynamicZip[Self <: Tuple, T2 <: Tuple](t1: Self, t2: T2): Zip[Self, T2] = {
+    if (t1.size == 0 || t2.size == 0) ().asInstanceOf[Zip[Self, T2]]
     else Tuple.fromArray(
       t1.asInstanceOf[Product].productIterator.zip(
       t2.asInstanceOf[Product].productIterator).toArray // TODO use toIArray of Object to avoid double/triple array copy
-    ).asInstanceOf[Zip[This, T2]]
+    ).asInstanceOf[Zip[Self, T2]]
   }
 
-  def dynamicMap[This <: Tuple, F[_]](self: This, f: [t] => t => F[t]): Map[This, F] =
+  def dynamicMap[Self <: Tuple, F[_]](self: Self, f: [t] => t => F[t]): Map[Self, F] =
     Tuple.fromArray(self.asInstanceOf[Product].productIterator.map(f(_)).toArray) // TODO use toIArray of Object to avoid double/triple array copy
-      .asInstanceOf[Map[This, F]]
+      .asInstanceOf[Map[Self, F]]
 
   def consIterator(head: Any, tail: Tuple): Iterator[Any] =
     Iterator.single(head) ++ tail.asInstanceOf[Product].productIterator

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]]