Replace EmptyTuple implementation from Unit to Tuple0

Author: nicolasstucki

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