Rename scala.runtime.{Tuple => Tuples}

smarter · smarter · commit aaa6ec1dc51a · 2021-01-05T20:59:15.000+01:00
To avoid confusion with scala.Tuple. Part of #10602.
diff --git a/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Apply.scala b/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Apply.scala
@@ -21,7 +21,7 @@ class Apply {
 
   @Benchmark
   def tupleApply(): Any = {
-    runtime.Tuple.apply(tuple, index)
+    runtime.Tuples.apply(tuple, index)
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Concat.scala b/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Concat.scala
@@ -27,6 +27,6 @@ class Concat {
 
   @Benchmark
   def tupleConcat(): Tuple = {
-    runtime.Tuple.concat(tuple1, tuple2)
+    runtime.Tuples.concat(tuple1, tuple2)
   }
 }
diff --git a/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Cons.scala b/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Cons.scala
@@ -23,7 +23,7 @@ class Cons {
 
   @Benchmark
   def tupleCons(): Tuple = {
-    runtime.Tuple.cons("elem", tuple)
+    runtime.Tuples.cons("elem", tuple)
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Conversions.scala b/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Conversions.scala
@@ -23,27 +23,27 @@ class Conversions {
 
   @Benchmark
   def tupleToArray(): Array[Object] = {
-    runtime.Tuple.toArray(tuple)
+    runtime.Tuples.toArray(tuple)
   }
 
   @Benchmark
   def tupleToIArray(): IArray[Object] = {
-    runtime.Tuple.toIArray(tuple)
+    runtime.Tuples.toIArray(tuple)
   }
 
   @Benchmark
   def tupleFromArray(): Tuple = {
-    runtime.Tuple.fromArray(array)
+    runtime.Tuples.fromArray(array)
   }
 
   @Benchmark
   def tupleFromIArray(): Tuple = {
-    runtime.Tuple.fromIArray(iarray)
+    runtime.Tuples.fromIArray(iarray)
   }
 
   @Benchmark
   def productToArray(): Array[Object] = {
-    runtime.Tuple.productToArray(tuple.asInstanceOf[Product])
+    runtime.Tuples.productToArray(tuple.asInstanceOf[Product])
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Map.scala b/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Map.scala
@@ -29,7 +29,7 @@ class Map {
 
   @Benchmark
   def tupleMap(): Tuple = {
-    runtime.Tuple.map[Id](tuple, [T] => (x:T) => x.asInstanceOf[String].updated(0, 'a').asInstanceOf[T])
+    runtime.Tuples.map[Id](tuple, [T] => (x:T) => x.asInstanceOf[String].updated(0, 'a').asInstanceOf[T])
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Tail.scala b/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Tail.scala
@@ -21,7 +21,7 @@ class Tail {
 
   @Benchmark
   def tupleTail(): Tuple = {
-    runtime.Tuple.tail(tuple)
+    runtime.Tuples.tail(tuple)
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Zip.scala b/bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Zip.scala
@@ -27,7 +27,7 @@ class Zip {
 
   @Benchmark
   def tupleZip(): Tuple = {
-    runtime.Tuple.zip(tuple1, tuple2)
+    runtime.Tuples.zip(tuple1, tuple2)
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/tuples/Drop.scala b/bench-run/src/main/scala/tuples/Drop.scala
@@ -23,7 +23,7 @@ class Drop {
 
   @Benchmark
   def tupleDrop(): Tuple = {
-    runtime.Tuple.drop(tuple, half)
+    runtime.Tuples.drop(tuple, half)
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/tuples/Split.scala b/bench-run/src/main/scala/tuples/Split.scala
@@ -23,7 +23,7 @@ class Split {
 
   @Benchmark
   def tupleSplit(): (Tuple, Tuple) = {
-    runtime.Tuple.splitAt(tuple, half)
+    runtime.Tuples.splitAt(tuple, half)
   }
 
   @Benchmark
diff --git a/bench-run/src/main/scala/tuples/Take.scala b/bench-run/src/main/scala/tuples/Take.scala
@@ -23,7 +23,7 @@ class Take {
 
   @Benchmark
   def tupleTake(): Tuple = {
-    runtime.Tuple.take(tuple, half)
+    runtime.Tuples.take(tuple, half)
   }
 
   @Benchmark
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -867,20 +867,20 @@ class Definitions {
 
     def TupleXXL_fromIterator(using Context): Symbol = TupleXXLModule.requiredMethod("fromIterator")
 
-  @tu lazy val RuntimeTupleModule: Symbol = requiredModule("scala.runtime.Tuple")
-  @tu lazy val RuntimeTupleModuleClass: Symbol = RuntimeTupleModule.moduleClass
-    lazy val RuntimeTuple_consIterator: Symbol = RuntimeTupleModule.requiredMethod("consIterator")
-    lazy val RuntimeTuple_concatIterator: Symbol = RuntimeTupleModule.requiredMethod("concatIterator")
-    lazy val RuntimeTuple_apply: Symbol = RuntimeTupleModule.requiredMethod("apply")
-    lazy val RuntimeTuple_cons: Symbol = RuntimeTupleModule.requiredMethod("cons")
-    lazy val RuntimeTuple_size: Symbol = RuntimeTupleModule.requiredMethod("size")
-    lazy val RuntimeTuple_tail: Symbol = RuntimeTupleModule.requiredMethod("tail")
-    lazy val RuntimeTuple_concat: Symbol = RuntimeTupleModule.requiredMethod("concat")
-    lazy val RuntimeTuple_toArray: Symbol = RuntimeTupleModule.requiredMethod("toArray")
-    lazy val RuntimeTuple_productToArray: Symbol = RuntimeTupleModule.requiredMethod("productToArray")
-    lazy val RuntimeTuple_isInstanceOfTuple: Symbol = RuntimeTupleModule.requiredMethod("isInstanceOfTuple")
-    lazy val RuntimeTuple_isInstanceOfEmptyTuple: Symbol = RuntimeTupleModule.requiredMethod("isInstanceOfEmptyTuple")
-    lazy val RuntimeTuple_isInstanceOfNonEmptyTuple: Symbol = RuntimeTupleModule.requiredMethod("isInstanceOfNonEmptyTuple")
+  @tu lazy val RuntimeTuplesModule: Symbol = requiredModule("scala.runtime.Tuples")
+  @tu lazy val RuntimeTuplesModuleClass: Symbol = RuntimeTuplesModule.moduleClass
+    lazy val RuntimeTuples_consIterator: Symbol = RuntimeTuplesModule.requiredMethod("consIterator")
+    lazy val RuntimeTuples_concatIterator: Symbol = RuntimeTuplesModule.requiredMethod("concatIterator")
+    lazy val RuntimeTuples_apply: Symbol = RuntimeTuplesModule.requiredMethod("apply")
+    lazy val RuntimeTuples_cons: Symbol = RuntimeTuplesModule.requiredMethod("cons")
+    lazy val RuntimeTuples_size: Symbol = RuntimeTuplesModule.requiredMethod("size")
+    lazy val RuntimeTuples_tail: Symbol = RuntimeTuplesModule.requiredMethod("tail")
+    lazy val RuntimeTuples_concat: Symbol = RuntimeTuplesModule.requiredMethod("concat")
+    lazy val RuntimeTuples_toArray: Symbol = RuntimeTuplesModule.requiredMethod("toArray")
+    lazy val RuntimeTuples_productToArray: Symbol = RuntimeTuplesModule.requiredMethod("productToArray")
+    lazy val RuntimeTuples_isInstanceOfTuple: Symbol = RuntimeTuplesModule.requiredMethod("isInstanceOfTuple")
+    lazy val RuntimeTuples_isInstanceOfEmptyTuple: Symbol = RuntimeTuplesModule.requiredMethod("isInstanceOfEmptyTuple")
+    lazy val RuntimeTuples_isInstanceOfNonEmptyTuple: Symbol = RuntimeTuplesModule.requiredMethod("isInstanceOfNonEmptyTuple")
 
   // Annotation base classes
   @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
diff --git a/compiler/src/dotty/tools/dotc/transform/TupleOptimizations.scala b/compiler/src/dotty/tools/dotc/transform/TupleOptimizations.scala
@@ -24,13 +24,13 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
   def phaseName: String = "genericTuples"
 
   override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
-    if (!tree.symbol.exists || tree.symbol.owner != defn.RuntimeTupleModuleClass) tree
-    else if (tree.symbol == defn.RuntimeTuple_cons) transformTupleCons(tree)
-    else if (tree.symbol == defn.RuntimeTuple_tail) transformTupleTail(tree)
-    else if (tree.symbol == defn.RuntimeTuple_size) transformTupleSize(tree)
-    else if (tree.symbol == defn.RuntimeTuple_concat) transformTupleConcat(tree)
-    else if (tree.symbol == defn.RuntimeTuple_apply) transformTupleApply(tree)
-    else if (tree.symbol == defn.RuntimeTuple_toArray) transformTupleToArray(tree)
+    if (!tree.symbol.exists || tree.symbol.owner != defn.RuntimeTuplesModuleClass) tree
+    else if (tree.symbol == defn.RuntimeTuples_cons) transformTupleCons(tree)
+    else if (tree.symbol == defn.RuntimeTuples_tail) transformTupleTail(tree)
+    else if (tree.symbol == defn.RuntimeTuples_size) transformTupleSize(tree)
+    else if (tree.symbol == defn.RuntimeTuples_concat) transformTupleConcat(tree)
+    else if (tree.symbol == defn.RuntimeTuples_apply) transformTupleApply(tree)
+    else if (tree.symbol == defn.RuntimeTuples_toArray) transformTupleToArray(tree)
     else tree
 
   private def transformTupleCons(tree: tpd.Apply)(using Context): Tree = {
@@ -49,14 +49,14 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
         else {
           // val it = Iterator.single(head) ++ tail.asInstanceOf[Product].productIterator
           // TupleN+1(it.next(), ..., it.next())
-          val fullIterator = ref(defn.RuntimeTuple_consIterator).appliedToArgs(head :: tail :: Nil)
+          val fullIterator = ref(defn.RuntimeTuples_consIterator).appliedToArgs(head :: tail :: Nil)
           evalOnce(fullIterator) { it =>
             knownTupleFromIterator(tpes.length, it).asInstance(tree.tpe)
           }
         }
       case _ =>
         // No optimization, keep:
-        // scala.runtime.Tuple.cons(tail, head)
+        // scala.runtime.Tuples.cons(tail, head)
         tree
     }
   }
@@ -93,7 +93,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
           tup.asInstance(defn.TupleXXLClass.typeRef).select("tailXXL".toTermName)
       case None =>
         // No optimization, keep:
-        // scala.runtime.Tuple.tail(tup)
+        // scala.runtime.Tuples.tail(tup)
         tree
     }
   }
@@ -127,14 +127,14 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
         else {
           // val it = self.asInstanceOf[Product].productIterator ++ that.asInstanceOf[Product].productIterator
           // TupleN+M(it.next(), ..., it.next())
-          val fullIterator = ref(defn.RuntimeTuple_concatIterator).appliedToArgs(tree.args)
+          val fullIterator = ref(defn.RuntimeTuples_concatIterator).appliedToArgs(tree.args)
           evalOnce(fullIterator) { it =>
             knownTupleFromIterator(n + m, it).asInstance(tree.tpe)
           }
         }
       case _ =>
         // No optimization, keep:
-        // scala.runtime.Tuple.cons(self, that)
+        // scala.runtime.Tuples.cons(self, that)
         tree
     }
   }
@@ -161,7 +161,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
         tree
       case _ =>
         // No optimization, keep:
-        // scala.runtime.Tuple.apply(tup, n)
+        // scala.runtime.Tuples.apply(tup, n)
         tree
     }
   }
@@ -175,14 +175,14 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
           // Array.emptyObjectArray
           ref(defn.ArrayModule).select("emptyObjectArray".toTermName).ensureApplied
         else if (size <= MaxTupleArity)
-          // scala.runtime.Tuple.productToArray(tup.asInstanceOf[Product])
-          ref(defn.RuntimeTuple_productToArray).appliedTo(tup.asInstance(defn.ProductClass.typeRef))
+          // scala.runtime.Tuples.productToArray(tup.asInstanceOf[Product])
+          ref(defn.RuntimeTuples_productToArray).appliedTo(tup.asInstance(defn.ProductClass.typeRef))
         else
           // tup.asInstanceOf[TupleXXL].elems.clone()
           tup.asInstance(defn.TupleXXLClass.typeRef).select(nme.toArray)
       case None =>
         // No optimization, keep:
-        // scala.runtime.Tuple.toArray(tup)
+        // scala.runtime.Tuples.toArray(tup)
         tree
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -311,17 +311,17 @@ object TypeTestsCasts {
          *
          *    expr.isInstanceOf[A | B]  ~~>  expr.isInstanceOf[A] | expr.isInstanceOf[B]
          *    expr.isInstanceOf[A & B]  ~~>  expr.isInstanceOf[A] & expr.isInstanceOf[B]
-         *    expr.isInstanceOf[Tuple]          ~~>  scala.runtime.Tuple.isInstanceOfTuple(expr)
-         *    expr.isInstanceOf[EmptyTuple]     ~~>  scala.runtime.Tuple.isInstanceOfEmptyTuple(expr)
-         *    expr.isInstanceOf[NonEmptyTuple]  ~~>  scala.runtime.Tuple.isInstanceOfNonEmptyTuple(expr)
-         *    expr.isInstanceOf[*:[_, _]]       ~~>  scala.runtime.Tuple.isInstanceOfNonEmptyTuple(expr)
+         *    expr.isInstanceOf[Tuple]          ~~>  scala.runtime.Tuples.isInstanceOfTuple(expr)
+         *    expr.isInstanceOf[EmptyTuple]     ~~>  scala.runtime.Tuples.isInstanceOfEmptyTuple(expr)
+         *    expr.isInstanceOf[NonEmptyTuple]  ~~>  scala.runtime.Tuples.isInstanceOfNonEmptyTuple(expr)
+         *    expr.isInstanceOf[*:[_, _]]       ~~>  scala.runtime.Tuples.isInstanceOfNonEmptyTuple(expr)
          *
          *  The transform happens before erasure of `testType`, thus cannot be merged
          *  with `transformIsInstanceOf`, which depends on erased type of `testType`.
          */
         def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
           case tref: TermRef if tref.symbol == defn.EmptyTupleModule =>
-            ref(defn.RuntimeTuple_isInstanceOfEmptyTuple).appliedTo(expr)
+            ref(defn.RuntimeTuples_isInstanceOfEmptyTuple).appliedTo(expr)
           case _: SingletonType =>
             expr.isInstance(testType).withSpan(tree.span)
           case OrType(tp1, tp2) =>
@@ -343,11 +343,11 @@ object TypeTestsCasts {
                 .and(isArrayTest(e))
             }
           case tref: TypeRef if tref.symbol == defn.TupleClass =>
-            ref(defn.RuntimeTuple_isInstanceOfTuple).appliedTo(expr)
+            ref(defn.RuntimeTuples_isInstanceOfTuple).appliedTo(expr)
           case tref: TypeRef if tref.symbol == defn.NonEmptyTupleClass =>
-            ref(defn.RuntimeTuple_isInstanceOfNonEmptyTuple).appliedTo(expr)
+            ref(defn.RuntimeTuples_isInstanceOfNonEmptyTuple).appliedTo(expr)
           case AppliedType(tref: TypeRef, _) if tref.symbol == defn.PairClass =>
-            ref(defn.RuntimeTuple_isInstanceOfNonEmptyTuple).appliedTo(expr)
+            ref(defn.RuntimeTuples_isInstanceOfNonEmptyTuple).appliedTo(expr)
           case _ =>
             val erasedTestType = erasure(testType)
             transformIsInstanceOf(expr, erasedTestType, erasedTestType, flagUnrelated)
diff --git a/library/src-bootstrapped/scala/Tuple.scala b/library/src-bootstrapped/scala/Tuple.scala
diff --git a/library/src-non-bootstrapped/scala/Tuple.scala b/library/src-non-bootstrapped/scala/Tuple.scala
diff --git a/library/src-non-bootstrapped/scala/runtime/Tuple.scala b/library/src-non-bootstrapped/scala/runtime/Tuple.scala
diff --git a/library/src/scala/runtime/Tuples.scala b/library/src/scala/runtime/Tuples.scala
diff --git a/tests/run-staging/staged-tuples/StagedTuple.scala b/tests/run-staging/staged-tuples/StagedTuple.scala

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ class Apply {`
`21`	`21`
`22`	`22`	`@Benchmark`
`23`	`23`	`def tupleApply(): Any = {`
`24`		`- runtime.Tuple.apply(tuple, index)`
	`24`	`+ runtime.Tuples.apply(tuple, index)`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,6 @@ class Concat {`
`27`	`27`
`28`	`28`	`@Benchmark`
`29`	`29`	`def tupleConcat(): Tuple = {`
`30`		`- runtime.Tuple.concat(tuple1, tuple2)`
	`30`	`+ runtime.Tuples.concat(tuple1, tuple2)`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class Cons {`
`23`	`23`
`24`	`24`	`@Benchmark`
`25`	`25`	`def tupleCons(): Tuple = {`
`26`		`- runtime.Tuple.cons("elem", tuple)`
	`26`	`+ runtime.Tuples.cons("elem", tuple)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -23,27 +23,27 @@ class Conversions {`
`23`	`23`
`24`	`24`	`@Benchmark`
`25`	`25`	`def tupleToArray(): Array[Object] = {`
`26`		`- runtime.Tuple.toArray(tuple)`
	`26`	`+ runtime.Tuples.toArray(tuple)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`@Benchmark`
`30`	`30`	`def tupleToIArray(): IArray[Object] = {`
`31`		`- runtime.Tuple.toIArray(tuple)`
	`31`	`+ runtime.Tuples.toIArray(tuple)`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`@Benchmark`
`35`	`35`	`def tupleFromArray(): Tuple = {`
`36`		`- runtime.Tuple.fromArray(array)`
	`36`	`+ runtime.Tuples.fromArray(array)`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`@Benchmark`
`40`	`40`	`def tupleFromIArray(): Tuple = {`
`41`		`- runtime.Tuple.fromIArray(iarray)`
	`41`	`+ runtime.Tuples.fromIArray(iarray)`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`@Benchmark`
`45`	`45`	`def productToArray(): Array[Object] = {`
`46`		`- runtime.Tuple.productToArray(tuple.asInstanceOf[Product])`
	`46`	`+ runtime.Tuples.productToArray(tuple.asInstanceOf[Product])`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ class Map {`
`29`	`29`
`30`	`30`	`@Benchmark`
`31`	`31`	`def tupleMap(): Tuple = {`
`32`		`- runtime.Tuple.map[Id](tuple, [T] => (x:T) => x.asInstanceOf[String].updated(0, 'a').asInstanceOf[T])`
	`32`	`+ runtime.Tuples.map[Id](tuple, [T] => (x:T) => x.asInstanceOf[String].updated(0, 'a').asInstanceOf[T])`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ class Tail {`
`21`	`21`
`22`	`22`	`@Benchmark`
`23`	`23`	`def tupleTail(): Tuple = {`
`24`		`- runtime.Tuple.tail(tuple)`
	`24`	`+ runtime.Tuples.tail(tuple)`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ class Zip {`
`27`	`27`
`28`	`28`	`@Benchmark`
`29`	`29`	`def tupleZip(): Tuple = {`
`30`		`- runtime.Tuple.zip(tuple1, tuple2)`
	`30`	`+ runtime.Tuples.zip(tuple1, tuple2)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class Drop {`
`23`	`23`
`24`	`24`	`@Benchmark`
`25`	`25`	`def tupleDrop(): Tuple = {`
`26`		`- runtime.Tuple.drop(tuple, half)`
	`26`	`+ runtime.Tuples.drop(tuple, half)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class Split {`
`23`	`23`
`24`	`24`	`@Benchmark`
`25`	`25`	`def tupleSplit(): (Tuple, Tuple) = {`
`26`		`- runtime.Tuple.splitAt(tuple, half)`
	`26`	`+ runtime.Tuples.splitAt(tuple, half)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`@Benchmark`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class Take {`
`23`	`23`
`24`	`24`	`@Benchmark`
`25`	`25`	`def tupleTake(): Tuple = {`
`26`		`- runtime.Tuple.take(tuple, half)`
	`26`	`+ runtime.Tuples.take(tuple, half)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`@Benchmark`