Special-case tuple specialised superclass type args

Author: dwijnand

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -415,7 +415,48 @@ class ClassfileParser(
                   if (argsBuf != null) argsBuf += arg
                 }
                 accept('>')
-                if (skiptvs) tp else AppliedType(tp, argsBuf.toList)
+                if (skiptvs) tp else
+                  // Fix the type arguments for specialised tuples.
+                  // For example, `Tuple2$mcIC$sp` actually extends `Tuple<Object, Object>`
+                  // instead of `Tuple<Integer, Character>`.  That could be simply an
+                  // accident or it could be to avoid having to also generate the bridge
+                  // methods for the accessors.  Seeing as the whole point of the classes
+                  // is to avoid boxing, I kind of like it, as it forces the use of the
+                  // specialised accessor methods (eg `_1$mcI$sp()` which returns int).
+                  // But it's a problem when running -Ycheck after TupleSpecialisation
+                  // as the tree `new Tuple2$mcIC$sp(1, 'a')` doesn't typecheck against
+                  // the expected `(Int, Char)` type.
+                  val args = (if owner == null then "" else owner.name.toString) match
+                    case "Tuple1$mcD$sp"  => List(defn.DoubleType)
+                    case "Tuple1$mcI$sp"  => List(defn.IntType)
+                    case "Tuple1$mcJ$sp"  => List(defn.LongType)
+                    case "Tuple2$mcCC$sp" => List(defn.CharType, defn.CharType)
+                    case "Tuple2$mcCD$sp" => List(defn.CharType, defn.DoubleType)
+                    case "Tuple2$mcCI$sp" => List(defn.CharType, defn.IntType)
+                    case "Tuple2$mcCJ$sp" => List(defn.CharType, defn.LongType)
+                    case "Tuple2$mcCZ$sp" => List(defn.CharType, defn.BooleanType)
+                    case "Tuple2$mcDC$sp" => List(defn.DoubleType, defn.CharType)
+                    case "Tuple2$mcDD$sp" => List(defn.DoubleType, defn.DoubleType)
+                    case "Tuple2$mcDI$sp" => List(defn.DoubleType, defn.IntType)
+                    case "Tuple2$mcDJ$sp" => List(defn.DoubleType, defn.LongType)
+                    case "Tuple2$mcDZ$sp" => List(defn.DoubleType, defn.BooleanType)
+                    case "Tuple2$mcIC$sp" => List(defn.IntType, defn.CharType)
+                    case "Tuple2$mcID$sp" => List(defn.IntType, defn.DoubleType)
+                    case "Tuple2$mcII$sp" => List(defn.IntType, defn.IntType)
+                    case "Tuple2$mcIJ$sp" => List(defn.IntType, defn.LongType)
+                    case "Tuple2$mcIZ$sp" => List(defn.IntType, defn.BooleanType)
+                    case "Tuple2$mcJC$sp" => List(defn.LongType, defn.CharType)
+                    case "Tuple2$mcJD$sp" => List(defn.LongType, defn.DoubleType)
+                    case "Tuple2$mcJI$sp" => List(defn.LongType, defn.IntType)
+                    case "Tuple2$mcJJ$sp" => List(defn.LongType, defn.LongType)
+                    case "Tuple2$mcJZ$sp" => List(defn.LongType, defn.BooleanType)
+                    case "Tuple2$mcZC$sp" => List(defn.BooleanType, defn.CharType)
+                    case "Tuple2$mcZD$sp" => List(defn.BooleanType, defn.DoubleType)
+                    case "Tuple2$mcZI$sp" => List(defn.BooleanType, defn.IntType)
+                    case "Tuple2$mcZJ$sp" => List(defn.BooleanType, defn.LongType)
+                    case "Tuple2$mcZZ$sp" => List(defn.BooleanType, defn.BooleanType)
+                    case _                => argsBuf.toList
+                  AppliedType(tp, args)
               }
               else tp
             case tp =>