Top level imports of universal methods induce ambiguity

[som-snytt]

Compiler version

3.1.1

Minimized code

➜  snips cat gottenclass.scala

object X
object Y

import X.*
import Y.*

def f = getClass  // ambiguous

class C {
  import X.*
  import Y.*
  def g = getClass  // OK, "normal" definition
}

@main def test() =
  println(f)
  println(C().g)

Output

➜  snips scalac gottenclass.scala
-- [E049] Reference Error: gottenclass.scala:8:8 -----------------------------------------------------------------------
8 |def f = getClass
  |        ^^^^^^^^
  |        Reference to getClass is ambiguous,
  |        it is both imported by import X._
  |        and imported subsequently by import Y._

longer explanation available when compiling with `-explain`
1 error found

Expectation

The Scala 2 fix was that "root imports" do not import universal methods. That was to avoid a bug where secondary constructors used getClass and got Predef.getClass.

In this case, getClass would be expected to pick up the class of the enclosing package object, as happens with this.getClass.

Without the ambiguity and without this, getClass is resolved by some arbitrary wildcard import, which is obviously unintended. (That is, more unintended than importing from Predef.)

Real world example at https://github.com/lampepfl/dotty/blob/3.1.2/compiler/test/dotty/tools/utils.scala#L16 is one wildcard import away from ambiguity.

More importantly, that example shows a usage of getClass where class loading might be important (that is, getResource might be using an unexpected class path).

Related to #7713 except here the competing import is not a root import.