Fix inline proxy generation for opaque types referencing other opaque types

Author: jchyb

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

@@ -144,9 +144,25 @@ object Inliner:
           else Nil
         case _ => Nil
       val refinements = openOpaqueAliases(cls.givenSelfType)
+
+      // Map references from the proxied termRef to its recursive type
+      def mapTermRefReferences(recType: RecType, refinedType: Type) =
+        new TypeMap {
+          def apply(tp: Type) = tp match
+            case RefinedType(a: RefinedType, b, info) => RefinedType(apply(a), b, apply(info))
+            case RefinedType(a, b, info) => RefinedType(a, b, apply(info))
+            case TypeRef(prefix, des) => TypeRef(apply(prefix), des)
+            case termRef: TermRef if termRef == ref => recType.recThis
+            case _ => mapOver(tp)
+        }.apply(refinedType)
       val refinedType = refinements.foldLeft(ref: Type): (parent, refinement) =>
         RefinedType(parent, refinement._1, TypeAlias(refinement._2))
-      val refiningSym = newSym(InlineBinderName.fresh(), Synthetic, refinedType, span)
+
+      val recType = RecType.closeOver ( recType =>
+        mapTermRefReferences(recType, refinedType)
+      )
+
+      val refiningSym = newSym(InlineBinderName.fresh(), Synthetic, recType, span)
       refiningSym.termRef
 
     def unapply(refiningRef: TermRef)(using Context): Option[TermRef] =
@@ -387,7 +403,9 @@ class Inliner(val call: tpd.Tree)(using Context):
             val refiningRef = OpaqueProxy(ref, cls, call.span)
             val refiningSym = refiningRef.symbol.asTerm
             val refinedType = refiningRef.info
-            val refiningDef = ValDef(refiningSym, tpd.ref(ref).cast(refinedType), inferred = true).withSpan(span)
+            val refiningDef = addProxiesForRecurrentOpaques(
+              ValDef(refiningSym, tpd.ref(ref).cast(refinedType), inferred = true).withSpan(span)
+            )
             inlining.println(i"add opaque alias proxy $refiningDef for $ref in $tp")
             bindingsBuf += refiningDef
             opaqueProxies += ((ref, refiningSym.termRef))
@@ -407,6 +425,29 @@ class Inliner(val call: tpd.Tree)(using Context):
           }
     )
 
+  /** Transforms proxies that reference other opaque types, like for:
+   * object Obj1 { opaque type A = Int }
+   * object Obj2 { opaque type B = A }
+   * and proxy$1 of type Obj2.type{type B = Obj2.A }
+   * creates proxy$2 of type Obj1.type{type A = Int }
+   * and transforms proxy$1 into Obj2.type{type B = proxy$2.A }
+   */
+  private def addProxiesForRecurrentOpaques(binding: ValDef)(using Context): ValDef =
+    def fixRefinedTypes(ref: Type): Unit  =
+      ref match
+        case recType: RecType => fixRefinedTypes(recType.underlying)
+        case RefinedType(parent: RefinedType, name, info) =>
+          addOpaqueProxies(info.widen, binding.span, true)
+          fixRefinedTypes(parent)
+        case RefinedType(parent, name, info) =>
+          addOpaqueProxies(info.widen, binding.span, true)
+        case _ =>
+    fixRefinedTypes(binding.symbol.info)
+    binding.symbol.info = mapOpaques.typeMap(binding.symbol.info)
+    mapOpaques.transform(binding).asInstanceOf[ValDef]
+      .showing(i"transformed this binding exposing opaque aliases: $result", inlining)
+  end addProxiesForRecurrentOpaques
+
   /** If `binding` contains TermRefs that refer to objects with opaque
    *  type aliases, add proxy definitions that expose these aliases
    *  and substitute such TermRefs with theproxies. Example from pos/opaque-inline1.scala:

tests/pos/22359a.scala

@@ -0,0 +1,15 @@
+opaque type NT[N <: Tuple, V <: Tuple] = V
+opaque type System = NT[Tuple1["wires"], Tuple1[Any]]
+
+extension [N <: Tuple, V <: Tuple] (x: NT[N, V]) {
+  inline def apply(n: Int): Any =
+    x.productElement(n)
+}
+
+extension (system: System) {
+  inline def foo =
+    system.apply(0)
+}
+
+val simulation: System = ???
+val _ = simulation.foo

tests/pos/22359b.scala

@@ -0,0 +1,17 @@
+object Obj2:
+  opaque type NT[N <: Tuple, V <: Tuple] = V
+
+  extension [N <: Tuple, V <: Tuple] (x: NT[N, V]) {
+    inline def apply(n: Int): Any =
+      x.productElement(n)
+  }
+
+object Obj:
+  opaque type System = Obj2.NT[Tuple1["wires"], Tuple1[Any]]
+
+  extension (system: System) {
+    inline def foo = system.apply(0)
+  }
+import Obj._
+val simulation: System = ???
+val _ = simulation.foo