Proper handling of primitive getClass corner case

After the previous commit, t5568 started crashing, but it turns out that
it had always been wrong:

  1.asInstanceOf[Int & AnyRef].getClass

is supposed to return classOf[Integer] but actually returns
classOf[Int], when this test was imported from scalac, the checkfile was
changed to make the test pass instead of aligining the compiler behavior
with scalac. This commit fixes that: by dropping the `getClass` overload
defined in primitive value classes which confuses the compiler, see
`hasProblematicGetClass`.

Author: smarter

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

@@ -460,7 +460,19 @@ object desugar {
         case tree: MemberDef => Ident(tree.name.toTermName) :: Nil
         case PatDef(_, ids: List[Ident] @ unchecked, _, _) => ids
       }
-      val stats = impl.body.map(expandConstructor)
+
+      val stats0 = impl.body.map(expandConstructor)
+      val stats =
+        if (ctx.owner eq defn.ScalaPackageClass) && defn.hasProblematicGetClass(className) then
+          stats0.filterConserve {
+            case ddef: DefDef =>
+              ddef.name ne nme.getClass_
+            case _ =>
+              true
+          }
+        else
+          stats0
+
       if (isEnum) {
         val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase)
         if (enumCases.isEmpty)

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

@@ -1309,6 +1309,27 @@ class Definitions {
     else parents
   }
 
+  private val HasProblematicGetClass: Set[Name] = Set(
+    tpnme.AnyVal, tpnme.Byte, tpnme.Short, tpnme.Char, tpnme.Int, tpnme.Long, tpnme.Float, tpnme.Double,
+    tpnme.Unit, tpnme.Boolean)
+
+  /** When typing a primitive value class or AnyVal, we ignore the `getClass`
+   *  member: it's supposed to be an override of the `getClass` defined on `Any`,
+   *  but in dotty `Any#getClass` is polymorphic so it ends up being an overload.
+   *  This is especially problematic because it means that when writing:
+   *
+   *    1.asInstanceOf[Int & AnyRef].getClass
+   *
+   *  the `getClass` that returns `Class[Int]` defined in Int can be selected,
+   *  but this call is specified to return `classOf[Integer]`, see
+   *  tests/run/t5568.scala.
+   *
+   *  FIXME: remove all the `getClass` methods defined in the standard library
+   *  so we don't have to hot-patch it like this.
+   */
+  def hasProblematicGetClass(className: Name): Boolean =
+    HasProblematicGetClass.contains(className)
+
   /** Is synthesized symbol with alphanumeric name allowed to be used as an infix operator? */
   def isInfix(sym: Symbol)(implicit ctx: Context): Boolean =
     (sym eq Object_eq) || (sym eq Object_ne)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -187,11 +187,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           val savedIndex = readIndex
           readIndex = index(i)
           val sym = readSymbol()
-          entries(i) = sym
-          sym.infoOrCompleter match {
-            case info: ClassUnpickler => info.init()
-            case _ =>
-          }
+          if sym.exists then
+            entries(i) = sym
+            sym.infoOrCompleter match {
+              case info: ClassUnpickler => info.init()
+              case _ =>
+            }
           readIndex = savedIndex
         }
         i += 1
@@ -438,6 +439,10 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     var name = at(nameref, () => readName()(ctx))
     val owner = readSymbolRef()
 
+    if (name eq nme.getClass_) && defn.hasProblematicGetClass(owner.name) then
+      // skip this member
+      return NoSymbol
+
     var flags = unpickleScalaFlags(readLongNat(), name.isTypeName)
 
     name = name.adjustIfModuleClass(flags)

tests/run/t5568.check

@@ -1,9 +1,9 @@
 void
 int
-void
-void
-int
-int
+class scala.runtime.BoxedUnit
+class scala.runtime.BoxedUnit
+class java.lang.Integer
+class java.lang.Integer
 5
 5
 5