Fix additional test case

Certain macros could return nodes typed with incorrect ThisTypes, which
would reference module types outside of their scope.

We remap those problematic nodes to TermRefs pointing to objects, and
then possibly manually cast the returned node to the remapped type, as the
ensureConforms method would just leave the previous incorrect type after
confirming that the remapped type is a subtype of the previous incorrect
one.

Author: jchyb

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -574,17 +574,43 @@ object Inlines:
       val inlined = tpd.Inlined(call, bindings, expansion)
 
       val hasOpaquesInResultFromCallWithTransparentContext =
+        val owners = call.symbol.ownersIterator.toSet
         call.tpe.widenTermRefExpr.existsPart(
-          part => part.typeSymbol.is(Opaque) && call.symbol.ownersIterator.contains(part.typeSymbol.owner)
+          part => part.typeSymbol.is(Opaque) && owners.contains(part.typeSymbol.owner)
         )
 
+      /* Remap ThisType nodes that are incorrect in the inlined context.
+       * Incorrect ThisType nodes can cause unwanted opaque type dealiasing later
+       * See test i113461-d
+       * */
+      def fixThisTypeModuleClassReferences(tpe: Type): Type =
+        val owners = ctx.owner.ownersIterator.toSet
+        println("owners " + owners)
+        TreeTypeMap(
+          typeMap = new TypeMap:
+            override def stopAt = StopAt.Package
+            def apply(t: Type) = mapOver {
+              t match
+                case ThisType(tref @ TypeRef(prefix, _)) if tref.symbol.flags.is(Module) && !owners.contains(tref.symbol) =>
+                  TermRef(apply(prefix), tref.symbol.companionModule)
+                case _ => mapOver(t)
+            }
+        ).typeMap(tpe)
+
       if !hasOpaqueProxies && !hasOpaquesInResultFromCallWithTransparentContext then inlined
       else
-        val target =
+        val (target, forceCast) =
           if inlinedMethod.is(Transparent) then
-            call.tpe & unpackProxiesFromResultType(inlined)
-          else call.tpe
-        inlined.ensureConforms(target)
+            val unpacked = unpackProxiesFromResultType(inlined)
+            val withAdjustedThisTypes = if call.symbol.is(Macro) then fixThisTypeModuleClassReferences(unpacked) else unpacked
+            (call.tpe & withAdjustedThisTypes, withAdjustedThisTypes != unpacked)
+          else (call.tpe, false)
+        if forceCast then
+          // we need to force the cast for issues with ThisTypes, as ensureConforms will just
+          // check subtyping and then choose not to cast, leaving the previous, incorrect type
+          inlined.cast(target)
+        else
+          inlined.ensureConforms(target)
           // Make sure that the sealing with the declared type
           // is type correct. Without it we might get problems since the
           // expression's type is the opaque alias but the call's type is

tests/pos-macros/i13461-d/Macro_1.scala

@@ -0,0 +1,8 @@
+import scala.quoted.*
+opaque type MyOpaque = Int
+object MyOpaque:
+  val one: MyOpaque = 1
+  transparent inline def apply(): MyOpaque = ${ applyMacro }
+  private def applyMacro(using Quotes): Expr[MyOpaque] =
+    import quotes.reflect.*
+    '{ one }

tests/pos-macros/i13461-d/Test_2.scala

@@ -0,0 +1,8 @@
+trait Leak[T]:
+  type Out
+given [T]: Leak[T] with
+  type Out = T
+extension [T](t: T)(using l: Leak[T]) def leak: l.Out = ???
+
+val x = MyOpaque().leak
+val shouldWork = summon[x.type <:< MyOpaque]