Fix #11078: avoid widening F-bounds in type avoidance

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -3,7 +3,7 @@ package dotc
 package core
 
 import Contexts._, Types._, Symbols._, Names._, Flags._
-import SymDenotations._
+import Denotations._, SymDenotations._
 import util.Spans._
 import util.Stats
 import NameKinds.DepParamName
@@ -438,6 +438,8 @@ object TypeOps:
             tp.origin, fromBelow = variance > 0 || variance == 0 && tp.hasLowerBound)(using mapCtx)
           val lo1 = apply(lo)
           if (lo1 ne lo) lo1 else tp
+        case tp: LazyRef =>
+          TypeBounds.empty
         case _ =>
           mapOver(tp)
       }

tests/pos/i11078.scala

@@ -0,0 +1,29 @@
+trait Foo[A <: Foo[A]]
+trait FooCreator[A <: Foo[A]] {
+  def createFoo(): A
+}
+
+trait FooWrapper {
+  type A <: Foo[A]
+  def foo: A
+}
+object FooWrapper {
+  def apply[A0 <: Foo[A0]](toWrap: A0): FooWrapper { type A = A0 } = new FooWrapper {
+    type A = A0
+    def foo: A0 = toWrap
+  }
+}
+
+trait FooCreatorWrapper {
+  type A <: Foo[A]
+  def fooCreator: FooCreator[A]
+}
+
+sealed trait Bar
+object Bar {
+  case class Baz(wrapper: FooCreatorWrapper) extends Bar
+}
+
+def process(bar: Bar): FooWrapper = bar match {
+  case Bar.Baz(wrapper) => FooWrapper(wrapper.fooCreator.createFoo())
+}

tests/pos/i11078b.scala

@@ -0,0 +1,11 @@
+class Test {
+  trait Foo[A <: Foo[A]]
+
+  trait FooWrapper with self =>
+    type A <: Foo[A]
+    def doThing(foo: FooWrapper): FooWrapper { type A = self.A } = ???
+  end FooWrapper
+
+  val foos: scala.Seq[FooWrapper] = ???
+  val newFoo = foos.foldLeft(??? : FooWrapper)((topFoo, foo) => topFoo.doThing(foo))
+}