Avoid infinite recursion when looking for suggestions

[mbovel]

Keep a a set of seen parent symbols between rootsIn and rootsStrictlyIn to avoid infinitely growing paths that refer to the same value, such as Collection.this.O.O.O.O.O.O.O.... when computing import suggestions for:

trait Collection:
  val base: Collection = ???
  base.foo()

  object O extends Collection:
    def foo(): Int = ???

Fixes #22145.

[mbovel]

Reverting to draft for now, as we should look for more cases. For example, as noted by @natsukagami, this still fails:

trait Collection:

  def bar(base: Collection) = base.foo
  object a extends Collection:
    def foo: Int = 0
  object b extends Collection:
    def foo: Int = 1

[olhotak]

Reverting to draft for now, as we should look for more cases. For example, as noted by @natsukagami, this still fails:

trait Collection:

  def bar(base: Collection) = base.foo
  object a extends Collection:
    def foo: Int = 0
  object b extends Collection:
    def foo: Int = 1

I wonder whether this kind of recursion is what the seenNames inside def nestedRoots is intended to catch. Maybe the correct fix is that seenNames needs to be lifted out somewhere to the level of rootsIn/rootsStrictlyIn.

If I recall correctly, we did not figure out the original motivation for seenNames.

[mbovel]

I continue to wonder if we couldn't make seen a set of Symbols instead of TermRefs.

I initially thought this could be problem when several members have the same type symbol but with different params, for example:

class C[T]:
  extension (x: T) def f(): Int = 1

object O:
  val c0: C[String] = new C[String]
  val c1: C[Int] = new C[Int]
  //import c1.f
  2.f()

But there actually is already no suggestion for this example, even without c0.

So if we only consider objects and packages, as the documentation of suggestionRoots seems to imply, maybe it's okay to never visit the same symbol twice?

[mbovel]

Discussed with @odersky, who gave this example where making seen a set of Symbols would miss suggestions:

package foo

class C[T]:
  object Ext:
    extension (x: T) def f(): Int = 1

object O1 extends C[String]
object O2 extends C[Int]

def main =
  2.f()

Martin instead suggested to keep a set of seen parents symbols between rootsIn and rootsStrictlyIn.