Revert "Fix inline proxy generation for opaque types referencing other opaque types"

This reverts commit bf7bfa5.

Author: jchyb

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

@@ -162,28 +162,9 @@ object Inliner:
           else Nil
         case _ => Nil
       val refinements = openOpaqueAliases(cls.givenSelfType)
-
-      // Map references in the refinements from the proxied termRef
-      // to the recursive type of the refined type
-      // e.g.: Obj.type{type A = Obj.B; type B = Int} -> Obj.type{type A = <recthis>.B; type B = Int}
-      def mapRecTermRefReferences(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 recType = RecType.closeOver ( recType =>
-        mapRecTermRefReferences(recType, refinedType)
-      )
-
-      val refiningSym = newSym(InlineBinderName.fresh(), Synthetic, recType, span)
+      val refiningSym = newSym(InlineBinderName.fresh(), Synthetic, refinedType, span)
       refiningSym.termRef
 
     def unapply(refiningRef: TermRef)(using Context): Option[TermRef] =
@@ -438,9 +419,7 @@ 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 = addProxiesForRecurrentOpaques(
-              ValDef(refiningSym, tpd.ref(ref).cast(refinedType), inferred = true).withSpan(span)
-            )
+            val refiningDef = 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))
@@ -460,27 +439,6 @@ 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 = Obj1.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, name, info) =>
-          addOpaqueProxies(info.widen, binding.span, true)
-          fixRefinedTypes(parent)
-        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: