Replace EmptyTuple implementation from Unit to Tuple0

Author: nicolasstucki

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Apply.scala

@@ -13,7 +13,7 @@ class Apply {
   def setup(): Unit = {
     val size = sizeAndIndex.split(' ')(0).toInt
     index = sizeAndIndex.split(' ')(1).toInt
-    tuple = "elem" *: ()
+    tuple = "elem" *: Tuple()
 
     for (i <- 1 until size)
       tuple = "elem" *: tuple

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Concat.scala

@@ -11,7 +11,7 @@ class Concat {
   var tuple2: Tuple = _
 
   def tupleOfSize(n: Int): Tuple = {
-    var t: Tuple = ()
+    var t: Tuple = Tuple()
     for (i <- 1 to n)
       t = "elem" *: t
     t

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Cons.scala

@@ -12,7 +12,7 @@ class Cons {
 
   @Setup
   def setup(): Unit = {
-    tuple = ()
+    tuple = Tuple()
 
     for (i <- 1 to size)
       tuple = "elem" *: tuple

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Conversions.scala

@@ -12,7 +12,7 @@ class Conversions {
 
   @Setup
   def setup(): Unit = {
-    tuple = ()
+    tuple = Tuple()
 
     for (i <- 1 to size)
       tuple = "elem" *: tuple

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Map.scala

@@ -11,7 +11,7 @@ class Map {
 
   @Setup
   def setup(): Unit = {
-    tuple = ()
+    tuple = Tuple()
 
     for (i <- 1 to size)
       tuple = "elem" *: tuple

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Tail.scala

@@ -11,7 +11,7 @@ class Tail {
 
   @Setup
   def setup(): Unit = {
-    tuple = "elem" *: ()
+    tuple = "elem" *: Tuple()
 
     for (i <- 1 until size)
       tuple = "elem" *: tuple

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/TupleOps.scala

@@ -11,11 +11,11 @@ class TupleOps {
 
   @Setup
   def setup(): Unit = {
-    tuple1 = ()
+    tuple1 = Tuple()
     for (i <- 1 until 15)
       tuple1 = s"elem$i" *: tuple1
 
-    tuple2 = ()
+    tuple2 = Tuple()
     for (i <- 1 until 10)
       tuple2 = s"elem$i" *: tuple2
 
@@ -25,23 +25,23 @@ class TupleOps {
 
   def tupleFlatMap(tuple: Tuple, f: [A] => A => Tuple): Tuple = {
     def tailRecFlatMap(t: Tuple, acc: Tuple): Tuple = t match {
-      case () => acc
+      case Tuple() => acc
       case x *: rest => tailRecFlatMap(rest, acc ++ f(x))
     }
-    tailRecFlatMap(tuple, ())
+    tailRecFlatMap(tuple, Tuple())
   }
 
   def tupleReverse(tuple: Tuple): Tuple = {
     def tailRecReverse(t: Tuple, acc: Tuple): Tuple = t match {
-      case () => acc
+      case Tuple() => acc
       case x *: rest => tailRecReverse(rest, x *: acc)
     }
-    tailRecReverse(tuple, ())
+    tailRecReverse(tuple, Tuple())
   }
 
   def tupleMerge(tuple1: Tuple, tuple2: Tuple): Tuple = (tuple1, tuple2) match {
-    case (_, ()) => tuple1
-    case ((), _) => tuple2
+    case (_, Tuple()) => tuple1
+    case (Tuple(), _) => tuple2
     case (x *: xs, y *: ys) =>
       if (x.asInstanceOf[Int] <= y.asInstanceOf[Int]) x *: tupleMerge(xs, tuple2)
       else y *: tupleMerge(tuple1, ys)

bench-run/src/main/scala/dotty/tools/benchmarks/tuples/Zip.scala

@@ -13,8 +13,8 @@ class Zip {
 
   @Setup
   def setup(): Unit = {
-    tuple1 = ()
-    tuple2 = ()
+    tuple1 = Tuple()
+    tuple2 = Tuple()
 
     for (i <- 1 to size) {
       tuple1 = "el" *: tuple1

bench-run/src/main/scala/tuples/Drop.scala

@@ -12,7 +12,7 @@ class Drop {
 
   @Setup
   def setup(): Unit = {
-    tuple = ()
+    tuple = Tuple()
     half = size / 2
 
     for (i <- 1 to size)

bench-run/src/main/scala/tuples/Split.scala

@@ -12,7 +12,7 @@ class Split {
 
   @Setup
   def setup(): Unit = {
-    tuple = ()
+    tuple = Tuple()
     half = size / 2
 
     for (i <- 1 to size)

bench-run/src/main/scala/tuples/Take.scala

@@ -12,7 +12,7 @@ class Take {
 
   @Setup
   def setup(): Unit = {
-    tuple = ()
+    tuple = Tuple()
     half = size / 2
 
     for (i <- 1 to size)

community-build/community-projects/scodec

@@ -1337,7 +1337,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** Creates the nested pairs type tree repesentation of the type trees in `ts` */
   def nestedPairsTypeTree(ts: List[Tree])(implicit ctx: Context): Tree =
-    ts.foldRight[Tree](TypeTree(defn.UnitType))((x, acc) => AppliedTypeTree(TypeTree(defn.PairClass.typeRef), x :: acc :: Nil))
+    ts.foldRight[Tree](TypeTree(defn.EmptyTupleTypeRef))((x, acc) => AppliedTypeTree(TypeTree(defn.PairClass.typeRef), x :: acc :: Nil))
 
   /** Replaces all positions in `tree` with zero-extent positions */
   private def focusPositions(tree: Tree)(implicit ctx: Context): Tree = {

community-build/community-projects/shapeless

@@ -745,11 +745,14 @@ class Definitions {
   @tu lazy val TupleTypeRef: TypeRef = ctx.requiredClassRef("scala.Tuple")
   def TupleClass(implicit ctx: Context): ClassSymbol = TupleTypeRef.symbol.asClass
     @tu lazy val Tuple_cons: Symbol = TupleClass.requiredMethod("*:")
+  @tu lazy val EmptyTupleTypeRef: TypeRef = ctx.requiredClassRef("scala.EmptyTuple")
+  def EmptyTupleClass(implicit ctx: Context): ClassSymbol = EmptyTupleTypeRef.symbol.asClass
   @tu lazy val NonEmptyTupleTypeRef: TypeRef = ctx.requiredClassRef("scala.NonEmptyTuple")
   def NonEmptyTupleClass(implicit ctx: Context): ClassSymbol = NonEmptyTupleTypeRef.symbol.asClass
     lazy val NonEmptyTuple_tail: Symbol = NonEmptyTupleClass.requiredMethod("tail")
-
   @tu lazy val PairClass: ClassSymbol = ctx.requiredClass("scala.*:")
+
+  @tu lazy val Tuple0Module: Symbol = ctx.requiredModule("scala.runtime.Tuple0")
   @tu lazy val TupleXXLClass: ClassSymbol = ctx.requiredClass("scala.runtime.TupleXXL")
   def TupleXXLModule(implicit ctx: Context): Symbol = TupleXXLClass.companionModule
 
@@ -1185,7 +1188,7 @@ class Definitions {
       case _ if bound < 0 => Some(acc.reverse)
       case tp: AppliedType if defn.PairClass == tp.classSymbol => rec(tp.args(1), tp.args.head :: acc, bound - 1)
       case tp: AppliedType if defn.isTupleClass(tp.tycon.classSymbol) => Some(acc.reverse ::: tp.args)
-      case tp if tp.classSymbol == defn.UnitClass => Some(acc.reverse)
+      case tp if tp.classSymbol == defn.EmptyTupleClass => Some(acc.reverse)
       case _ => None
     }
     rec(tp.stripTypeVar, Nil, bound)
@@ -1296,7 +1299,7 @@ class Definitions {
     def syntheticParent(tparams: List[TypeSymbol]): Type =
       if (tparams.isEmpty) TupleTypeRef
       else TypeOps.nestedPairs(tparams.map(_.typeRef))
-    if (isTupleClass(cls) || cls == UnitClass) parents :+ syntheticParent(tparams)
+    if (isTupleClass(cls) || cls == EmptyTupleClass) parents :+ syntheticParent(tparams)
     else parents
   }
 
@@ -1394,6 +1397,7 @@ class Definitions {
       .updated(AnyValClass, ObjectClass)
       .updated(SingletonClass, ObjectClass)
       .updated(TupleClass, ObjectClass)
+      .updated(EmptyTupleClass, ObjectClass)
       .updated(NonEmptyTupleClass, ProductClass)
 
   // ----- Initialization ---------------------------------------------------

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -731,6 +731,6 @@ object TypeOps:
   }
 
   def nestedPairs(ts: List[Type])(using Context): Type =
-    ts.foldRight(defn.UnitType: Type)(defn.PairClass.typeRef.appliedTo(_, _))
+    ts.foldRight(defn.EmptyTupleTypeRef: Type)(defn.PairClass.typeRef.appliedTo(_, _))
 
 end TypeOps

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

@@ -2004,7 +2004,10 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Definitions_NothingType: Type = defn.NothingType
   def Definitions_NullType: Type = defn.NullType
   def Definitions_StringType: Type = defn.StringType
-
+  def Definitions_TupleType: Type = defn.TupleTypeRef
+  def Definitions_EmptyTupleType: Type = defn.EmptyTupleTypeRef
+  def Definitions_NonEmptyTupleType: Type = defn.NonEmptyTupleClass.typeRef
+  def Definitions_TupleConsType: Type = defn.PairClass.typeRef
 
   ///////////////
   // IMPLICITS //

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

@@ -163,6 +163,7 @@ class Erasure extends Phase with DenotTransformer {
     assert(isErasedType(tp) ||
            isAllowed(defn.ArrayClass, "Array.scala") ||
            isAllowed(defn.TupleClass, "Tuple.scala") ||
+           isAllowed(defn.EmptyTupleClass, "Tuple.scala") ||
            isAllowed(defn.NonEmptyTupleClass, "Tuple.scala") ||
            isAllowed(defn.PairClass, "Tuple.scala"),
         i"The type $tp - ${tp.toString} of class ${tp.getClass} of tree $tree : ${tree.tpe} / ${tree.getClass} is illegal after erasure, phase = ${ctx.phase.prev}")

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -69,8 +69,8 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
         val size = tpes.size
         assert(size > 0)
         if (size == 1)
-          // ()
-          Literal(Constant(()))
+          // scala.runtime.Tuple0
+          ref(defn.Tuple0Module.termRef)
         else if (size <= 5)
           // val t = tup.asInstanceOf[TupleN[...]]
           // TupleN-1(t._2, ..., t._n)
@@ -197,8 +197,8 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
 
   private def knownTupleFromIterator(size: Int, it: Tree)(implicit ctx: Context): Tree =
     if (size == 0)
-      // Unit for empty tuple
-      Literal(Constant(())) // TODO should this code be here? Or assert(size > specializedSize)
+      // EmptyTuple for empty tuple
+      ref(defn.EmptyTupleTypeRef) // TODO should this code be here? Or assert(size > specializedSize)
     else if (size <= MaxTupleArity) {
       // TupleN(it.next(), ..., it.next())
 

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -31,25 +31,25 @@ object TypeUtils {
       case ps => ps.reduceLeft(AndType(_, _))
     }
 
-    /** The arity of this tuple type, which can be made up of Unit, TupleX and `*:` pairs,
+    /** The arity of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs,
      *  or -1 if this is not a tuple type.
      */
     def tupleArity(implicit ctx: Context): Int = self match {
       case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         val arity = tl.tupleArity
         if (arity < 0) arity else arity + 1
       case tp1 =>
-        if (tp1.isRef(defn.UnitClass)) 0
+        if (tp1.isRef(defn.EmptyTupleClass)) 0
         else if (defn.isTupleClass(tp1.classSymbol)) tp1.dealias.argInfos.length
         else -1
     }
 
-    /** The element types of this tuple type, which can be made up of Unit, TupleX and `*:` pairs */
+    /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs */
     def tupleElementTypes(implicit ctx: Context): List[Type] = self match {
       case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         hd :: tl.tupleElementTypes
       case tp1 =>
-        if (tp1.isRef(defn.UnitClass)) Nil
+        if (tp1.isRef(defn.EmptyTupleClass)) Nil
         else if (defn.isTupleClass(tp1.classSymbol)) tp1.dealias.argInfos
         else throw new AssertionError("not a tuple")
     }

compiler/src/dotty/tools/dotc/transform/TupleOptimizations.scala

@@ -411,7 +411,9 @@ trait QuotesAndSplices {
       }
     }
 
-    val splicePat = typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
+    val splicePat =
+      if splices.isEmpty then ref(defn.Tuple0Module.termRef)
+      else typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
 
     val unapplySym = if (tree.quoted.isTerm) defn.InternalQuotedExpr_unapply else defn.InternalQuotedType_unapply
     val quoteClass = if (tree.quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass

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

@@ -2274,7 +2274,7 @@ class Typer extends Namer
         else List.fill(arity)(defn.AnyType)
       val elems = tree.trees.lazyZip(pts).map(typed(_, _))
       if (ctx.mode.is(Mode.Type))
-        elems.foldRight(TypeTree(defn.UnitType): Tree)((elemTpt, elemTpts) =>
+        elems.foldRight(TypeTree(defn.EmptyTupleTypeRef): Tree)((elemTpt, elemTpts) =>
           AppliedTypeTree(TypeTree(defn.PairClass.typeRef), List(elemTpt, elemTpts)))
           .withSpan(tree.span)
       else {

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -158,10 +158,10 @@ object Tuple {
   type Split[T <: Tuple, N <: Int] = (Take[T, N], Drop[T, N])
 
   /** Empty tuple */
-  def apply(): EmptyTuple = ()
+  def apply(): EmptyTuple = scala.runtime.Tuple0.asInstanceOf[EmptyTuple]
 
   /** Matches an empty tuple. */
-  def unapply(x: Any): Boolean = x.isInstanceOf[EmptyTuple]
+  def unapply(x: EmptyTuple): Boolean = x == scala.runtime.Tuple0
 
   /** Convert an array into a tuple of unknown arity and types */
   def fromArray[T](xs: Array[T]): Tuple = {
@@ -191,8 +191,8 @@ object Tuple {
     Tuple.fromArray(p.productIterator.toArray).asInstanceOf[m.MirroredElemTypes] // TODO use toIArray of Object to avoid double/triple array copy
 }
 
-/** Tuple of arity 0 */
-type EmptyTuple = Unit
+/** Tuple of arity zero */
+sealed trait EmptyTuple extends Tuple
 
 /** Tuple of arbitrary non-zero arity */
 sealed trait NonEmptyTuple extends Tuple with Product {

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -34,17 +34,17 @@ object deriving {
     trait Singleton extends Product {
       type MirroredMonoType = this.type
       type MirroredType = this.type
-      type MirroredElemTypes = Unit
-      type MirroredElemLabels = Unit
+      type MirroredElemTypes = EmptyTuple
+      type MirroredElemLabels = EmptyTuple
       def fromProduct(p: scala.Product) = this
     }
 
     /** A proxy for Scala 2 singletons, which do not inherit `Singleton` directly */
     class SingletonProxy(val value: AnyRef) extends Product {
       type MirroredMonoType = value.type
       type MirroredType = value.type
-      type MirroredElemTypes = Unit
-      type MirroredElemLabels = Unit
+      type MirroredElemTypes = EmptyTuple
+      type MirroredElemLabels = EmptyTuple
       def fromProduct(p: scala.Product) = value
     }
 

library/src-bootstrapped/scala/Tuple.scala

@@ -6,8 +6,8 @@ import scala.runtime.TupleXXL
 object TupledFunction {
 
   def tupledFunction0[F, G]: TupledFunction[F, G] = scala.TupledFunction[F, G](
-    tupledImpl = (f: F) => ((args: Unit) => f.asInstanceOf[() => Any].apply()).asInstanceOf[G],
-    untupledImpl = (g: G) => (() => g.asInstanceOf[Unit => Any].apply(())).asInstanceOf[F]
+    tupledImpl = (f: F) => ((args: EmptyTuple) => f.asInstanceOf[() => Any].apply()).asInstanceOf[G],
+    untupledImpl = (g: G) => (() => g.asInstanceOf[EmptyTuple => Any].apply(Tuple())).asInstanceOf[F]
   )
 
   def tupledFunction1[F, G]: TupledFunction[F, G] = scala.TupledFunction[F, G](

library/src-bootstrapped/scala/deriving.scala

@@ -38,7 +38,7 @@ class Expr[+T] private[scala] {
    *  ```
    */
   final def matches(that: Expr[Any])(using qctx: QuoteContext): Boolean =
-    !scala.internal.quoted.Expr.unapply[Unit, Unit](this)(using that, false, qctx).isEmpty
+    !scala.internal.quoted.Expr.unapply[EmptyTuple, EmptyTuple](this)(using that, false, qctx).isEmpty
 
   /** Checked cast to a `quoted.Expr[U]` */
   def cast[U](using tp: scala.quoted.Type[U])(using qctx: QuoteContext): scala.quoted.Expr[U] =
@@ -131,7 +131,7 @@ object Expr {
   def ofTuple(seq: Seq[Expr[Any]])(using qctx: QuoteContext): Expr[Tuple] = {
     seq match {
       case Seq() =>
-        unitExpr
+        '{ Tuple() }
       case Seq('{ $x1: $t1 }) =>
         '{ Tuple1($x1) }
       case Seq('{ $x1: $t1 }, '{ $x2: $t2 }) =>