Some comments as follow up for #7966

src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala

@@ -792,8 +792,8 @@ abstract class ClassfileParser(reader: ReusableInstance[ReusableDataReader]) {
         classTParams = tparams
         val parents = new ListBuffer[Type]()
         while (index < end) {
-          val parent = sig2type(tparams, skiptvs = false)
-          parents += (if (parent == ObjectTpeJava) ObjectTpe else parent)  // here the variance doesn't matter
+          val parent = sig2type(tparams, skiptvs = false) // here the variance doesn't matter
+          parents += (if (parent == ObjectTpeJava) ObjectTpe else parent)
         }
         ClassInfoType(parents.toList, instanceScope, sym)
       }

src/reflect/scala/reflect/internal/Definitions.scala

@@ -292,8 +292,19 @@ trait Definitions extends api.StandardDefinitions {
     lazy val BoxedUnitTpe    = BoxedUnitClass.tpe
     lazy val NothingTpe      = NothingClass.tpe
     lazy val NullTpe         = NullClass.tpe
+
+    /** Represents `java.lang.Object` as referenced from Scala code. */
     lazy val ObjectTpe       = ObjectClass.tpe
+
+    /** ObjectTpeJava is a TypeRef that's structurally equal to ObjectTpe, but with its own object identity.
+     *
+     * When referenced from Java (source or bytecode), `Object` should be considered equal to Scala's `Any`,
+     * as these types are both conceptually the top of the subtyping lattice of the respective languages.
+     *
+     * We use `ObjectTpeJava`'s identity to equate it, but not `ObjectTpe`, to `AnyTpe` in subtyping and type equality.
+     */
     lazy val ObjectTpeJava   = mkObjectTpeJava
+
     lazy val SerializableTpe = SerializableClass.tpe
     lazy val StringTpe       = StringClass.tpe
     lazy val ThrowableTpe    = ThrowableClass.tpe

src/reflect/scala/reflect/internal/Types.scala

@@ -2709,6 +2709,14 @@ trait Types
   private final class ClassNoArgsTypeRef(pre: Type, sym: Symbol) extends NoArgsTypeRef(pre, sym){
     override def contains(sym0: Symbol): Boolean = (sym eq sym0) || pre.contains(sym0)
   }
+
+  /** Expose ClassNoArgsTypeRef so we can create a non-uniqued ObjectTpeJava here and in reflect
+   *
+   * NOTE:
+   *   - definitions.ObjectTpe is forced first, so that it ends up in the unique cache.
+   *   - the created TypeRef is structurally equal to  ObjectTpe, but with its own identity
+   *   - we don't want the TypeRef we create here to be unique'd
+   */
   private[scala] def mkObjectTpeJava: Type = new ClassNoArgsTypeRef(definitions.ObjectTpe.prefix, definitions.ObjectClass)
 
   object TypeRef extends TypeRefExtractor {