Fix #10769: change synthesized type in def ordinal

As pointed out by @smarter in #10769, for the following code:

    package stm

    trait STMLike[F[_]] {
      import Internals._

      sealed abstract class Txn[+A] {}

      object Txn {
	def abort[A](e: Throwable): Txn[A] = Abort(e)
      }

      object Internals {
	case class Abort(error: Throwable) extends Txn[Nothing]
      }

    }

The compiler synthesized the following code for the object `Txn`:

    object Txn {
      type MirroredMonoType = STMLike.this.Txn[?]
      def ordinal(x: Txn.MirroredMonoType): Int =
	x match {
          case _:stm.STMLike.Internals.Abort => 0
	}

      def abort[A](e: Throwable): Txn[A] = Abort(e)
    }

In the method `ordinal`, the type for `Internals.Abort` is

    TypeRef(ThisType(TypeRef(ThisType(TypeRef(ThisType(TypeRef(NoPrefix,module class stm)),trait STMLike)),module class Internals$)),class Abort)

This type is incorrect, as we are not in the object `Internals`. The
explicit outer can only handle such types if it's static. In this
case, the object is not static, thus it crashes the explicit outer.

Co-authored-by: Guillaume Martres <[email protected]>

Author: liufengyun

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

@@ -225,7 +225,20 @@ object SymUtils:
 
     /** The typeRef with wildcard arguments for each type parameter */
     def rawTypeRef(using Context) =
-      self.typeRef.appliedTo(self.typeParams.map(_ => TypeBounds.emptyPolyKind))
+      // Change `pre.O.this` to `pre.O` if `O` is an object
+      // This is required to avoid owner crash in ExplicitOuter.
+      // See tests/pos/i10769.scala
+      val fixPrefix = new TypeMap {
+        def apply(tp: Type): Type = tp match {
+          case ThisType(tref: TypeRef)
+          if !tref.symbol.isStaticOwner && tref.symbol.is(Module) =>
+            TermRef(this(tref.prefix), tref.symbol.sourceModule)
+
+          case tp => mapOver(tp)
+        }
+      }
+
+      fixPrefix(self.typeRef).appliedTo(self.typeParams.map(_ => TypeBounds.emptyPolyKind))
 
     /** Is symbol a quote operation? */
     def isQuote(using Context): Boolean =

tests/pos/i10769.scala

@@ -0,0 +1,16 @@
+package stm
+
+trait STMLike[F[_]] {
+  import Internals._
+
+  sealed abstract class Txn[+A] {}
+
+  object Txn {
+    def abort[A](e: Throwable): Txn[A] = Abort(e)
+  }
+
+  object Internals {
+    case class Abort(error: Throwable) extends Txn[Nothing]
+  }
+
+}