treat EmptyTuple type alias the same as the aliased EmptyTuple.type and use EmptyTuple in compiler-generated code

Author: pweisenburger

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

@@ -1481,7 +1481,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])(using Context): Tree =
-    ts.foldRight[Tree](TypeTree(defn.EmptyTupleModule.termRef))((x, acc) => AppliedTypeTree(TypeTree(defn.PairClass.typeRef), x :: acc :: Nil))
+    ts.foldRight[Tree](TypeTree(defn.EmptyTupleType.typeRef))((x, acc) => AppliedTypeTree(TypeTree(defn.PairClass.typeRef), x :: acc :: Nil))
 
   /** Replaces all positions in `tree` with zero-extent positions */
   private def focusPositions(tree: Tree)(using Context): Tree = {

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

@@ -858,6 +858,7 @@ class Definitions {
   @tu lazy val TupleTypeRef: TypeRef = requiredClassRef("scala.Tuple")
   def TupleClass(using Context): ClassSymbol = TupleTypeRef.symbol.asClass
     @tu lazy val Tuple_cons: Symbol = TupleClass.requiredMethod("*:")
+  @tu lazy val EmptyTupleType: Symbol = ScalaPackageVal.requiredType("EmptyTuple")
   @tu lazy val EmptyTupleModule: Symbol = requiredModule("scala.EmptyTuple")
   @tu lazy val NonEmptyTupleTypeRef: TypeRef = requiredClassRef("scala.NonEmptyTuple")
   def NonEmptyTupleClass(using Context): ClassSymbol = NonEmptyTupleTypeRef.symbol.asClass

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

@@ -686,7 +686,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
   }
 
   private def erasePair(tp: Type)(using Context): Type = {
-    val arity = tp.tupleArity
+    val arity = tp.tupleArity(underErasure = true)
     if (arity < 0) defn.ProductClass.typeRef
     else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity)
     else defn.TupleXXLClass.typeRef

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

@@ -840,7 +840,7 @@ object TypeOps:
   }
 
   def nestedPairs(ts: List[Type])(using Context): Type =
-    ts.foldRight(defn.EmptyTupleModule.termRef: Type)(defn.PairClass.typeRef.appliedTo(_, _))
+    ts.foldRight(defn.EmptyTupleType.typeRef: Type)(defn.PairClass.typeRef.appliedTo(_, _))
 
   class StripTypeVarsMap(using Context) extends TypeMap:
     def apply(tp: Type) = mapOver(tp).stripTypeVar

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

@@ -49,31 +49,34 @@ object TypeUtils {
 
     /** 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.
+     *  We treat the arity under erasure specially to erase `T *: EmptyTuple` to `Product`
+     *  but `T *: EmptyTuple.type` to `Tuple1` for binary compatibility.
      */
-    def tupleArity(using Context): Int = self match {
+    def tupleArity(underErasure: Boolean)(using Context): Int = self match
       case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
-        val arity = tl.tupleArity
+        val arity = tl.tupleArity(underErasure)
         if (arity < 0) arity else arity + 1
-      case self: SingletonType =>
-        if self.termSymbol == defn.EmptyTupleModule then 0 else -1
-      case self if defn.isTupleClass(self.classSymbol) =>
-        self.dealias.argInfos.length
       case _ =>
-        -1
-    }
+        if self.termSymbol == defn.EmptyTupleModule then
+          if !underErasure || self.isInstanceOf[SingletonType] then 0 else -1
+        else if defn.isTupleClass(self.classSymbol) then
+          self.widenTermRefExpr.dealias.argInfos.length
+        else
+          -1
+
+    inline def tupleArity(using Context): Int = tupleArity(underErasure = false)
 
     /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs */
-    def tupleElementTypes(using Context): List[Type] = self match {
+    def tupleElementTypes(using Context): List[Type] = self match
       case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         hd :: tl.tupleElementTypes
-      case self: SingletonType =>
-        assert(self.termSymbol == defn.EmptyTupleModule, "not a tuple")
-        Nil
-      case self if defn.isTupleClass(self.classSymbol) =>
-        self.dealias.argInfos
-      case _ =>
-        throw new AssertionError("not a tuple")
-    }
+      case _  =>
+        if self.termSymbol == defn.EmptyTupleModule then
+          Nil
+        else if defn.isTupleClass(self.classSymbol) then
+          self.widenTermRefExpr.dealias.argInfos
+        else
+          throw new AssertionError("not a tuple")
 
     /** The `*:` equivalent of an instance of a Tuple class */
     def toNestedPairs(using Context): Type =

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

@@ -2727,7 +2727,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         if ctx.mode.is(Mode.Type) then typedType(_, _, mapPatternBounds = true)
         else typed(_, _))
       if (ctx.mode.is(Mode.Type))
-        elems.foldRight(TypeTree(defn.EmptyTupleModule.termRef): Tree)((elemTpt, elemTpts) =>
+        elems.foldRight(TypeTree(defn.EmptyTupleType.typeRef): Tree)((elemTpt, elemTpts) =>
           AppliedTypeTree(TypeTree(defn.PairClass.typeRef), List(elemTpt, elemTpts)))
           .withSpan(tree.span)
       else {

compiler/test-resources/repl/i5218

@@ -3,4 +3,4 @@ val tuple: (Int, String, Long) = (1,2,3)
 scala> 0.0 *: tuple
 val res0: (Double, Int, String, Long) = (0.0,1,2,3)
 scala> tuple ++ tuple
-val res1: Int *: String *: Long *: tuple.type = (1,2,3,1,2,3)
+val res1: (Int, String, Long, Int, String, Long) = (1,2,3,1,2,3)

tests/neg/i12049.check

@@ -26,7 +26,7 @@
 -- Error: tests/neg/i12049.scala:22:26 ---------------------------------------------------------------------------------
 22 |val z3: (A, B, A) = ??? : Reverse[(A, B, A)] // error
    |                          ^
-   |                          Match type reduction failed since selector  A *: EmptyTuple.type
+   |                          Match type reduction failed since selector  A *: EmptyTuple
    |                          matches none of the cases
    |
    |                              case t1 *: t2 *: ts => Tuple.Concat[Reverse[ts], (t2, t1)]
@@ -56,7 +56,7 @@
 -- Error: tests/neg/i12049.scala:26:29 ---------------------------------------------------------------------------------
 26 |val _ = summon[(A, B, A) =:= Reverse[(A, B, A)]] // error
    |                             ^
-   |                             Match type reduction failed since selector  A *: EmptyTuple.type
+   |                             Match type reduction failed since selector  A *: EmptyTuple
    |                             matches none of the cases
    |
    |                                 case t1 *: t2 *: ts => Tuple.Concat[Reverse[ts], (t2, t1)]