Correct owner chains when mixing byname implicits and inlining

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -730,6 +730,27 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       if (from == to) tree else loop(from, Nil, to :: Nil)
     }
 
+    /**
+     * Set the owner of every definition in this tree which is not itself contained in this
+     * tree to be `newowner`
+     */
+    def changeNonLocalOwners(newowner: Symbol)(implicit ctx: Context): Tree = {
+      val localOwners = mutable.HashSet[Symbol]()
+      val traverser = new TreeTraverser {
+
+        def traverse(tree: Tree)(implicit ctx: Context): Unit = {
+          tree match {
+            case _: DefTree => if(tree.symbol ne NoSymbol) localOwners += tree.symbol
+            case _ =>          traverseChildren(tree)
+          }
+        }
+      }
+      traverser.traverse(tree)
+      val nonLocalOwners = localOwners.filter(sym => !localOwners.contains(sym.owner)).toList.map(_.owner)
+      val newOwners = nonLocalOwners.map(_ => newowner)
+      new TreeTypeMap(oldOwners = nonLocalOwners, newOwners = newOwners).apply(tree)
+    }
+
     /** After phase `trans`, set the owner of every definition in this tree that was formerly
      *  owner by `from` to `to`.
      */

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -1577,7 +1577,7 @@ final class SearchRoot extends SearchHistory {
             val nrhss = rhss.map(rhsMap(_))
 
             val vdefs = (nsyms zip nrhss) map {
-              case (nsym, nrhs) => ValDef(nsym.asTerm, nrhs)
+              case (nsym, nrhs) => ValDef(nsym.asTerm, nrhs.changeNonLocalOwners(nsym))
             }
 
             val constr = ctx.newConstructor(classSym, Synthetic, Nil, Nil).entered

tests/pos/i5766.scala

@@ -0,0 +1,32 @@
+object Test1 {
+  trait Foo { def next: Foo }
+
+  inline implicit def foo(implicit loop: => Foo): Foo = new Foo { def next = loop }
+
+  def summon(implicit f: Foo) = ()
+  summon
+}
+
+object Test2 {
+  trait Foo { def next: Bar }
+  trait Bar { def next: Foo }
+
+  implicit def foo(implicit loop: => Bar): Foo = new Foo { def next = loop }
+  inline implicit def bar(implicit loop: Foo): Bar = new Bar { def next = loop }
+
+  def summon(implicit f: Foo) = ()
+  summon
+}
+
+object Test3 {
+  trait Foo { def next: Bar }
+  trait Bar { def next: Baz }
+  trait Baz { def next: Foo }
+
+  implicit def foo(implicit loop: Bar): Foo = new Foo { def next = loop }
+  inline implicit def bar(implicit loop: Baz): Bar = new Bar { def next = loop }
+  inline implicit def baz(implicit loop: => Foo): Baz = new Baz { def next = loop }
+
+  def summon(implicit f: Foo) = ()
+  summon
+}