Always exclude package objects from the implicit scope

Unlike Scala 2, in Dotty when constructing the implicit scope for a type
`pkgA.Foo`, we do not include the main package object (`pkgA.package`).
We don't include the package objects we define for top-level definitions
either.

However, when constructing the implicit scope for a type defined in a
package object (e.g. `pkgA.foo$package.Foo`), we did including the
implicits defined in the enclosing package object. This is problematic
because at the source-level it's hard to distinguish which definitions
will be included in the package object. For example, in the testcase
included in this commit, `summon[ToString[A.AB]]` used to succeed
because both the type `AB` and the given alias for `ToString[AB]` ended
up wrapped in a package object, but the other summon calls failed
because classes and given instances are not wrapped in a package object.

To fix this inconsistency, we now always exclude package objects from
the implicit scope, even for types defined in the implicit scope itself.
The companion object of classes and opaque types stays the preferred
place to put implicit definitions and is not affected by this change.

Author: smarter

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

@@ -507,10 +507,10 @@ trait ImplicitRunInfo {
     val incomplete: mutable.Set[Type] = mutable.Set()
 
     /** Is `sym` an anchor type for which givens may exist? Anchor types are classes,
-     *  opaque type aliases, and abstract types, but not type parameters
+     *  opaque type aliases, and abstract types, but not type parameters or package objects.
      */
     def isAnchor(sym: Symbol) =
-      sym.isClass && !sym.is(Package)
+      sym.isClass && !sym.is(Package) && (!sym.isPackageObject || ctx.scala2CompatMode)
       || sym.isOpaqueAlias
       || sym.is(Deferred, butNot = Param)
 
@@ -584,7 +584,7 @@ trait ImplicitRunInfo {
                 addPath(pre.prefix)
               }
             }
-            else {
+            else if (!pre.symbol.isPackageObject || ctx.scala2CompatMode)  {
               comps += pre
               addPath(pre.prefix)
             }

tests/neg/implicit-package-object.scala

@@ -0,0 +1,45 @@
+trait ToString[A] {
+  def print(a: A): Unit
+}
+
+package A {
+  case class AA(text: String)
+  given ToString[AA] = aa => println(aa.text)
+
+  opaque type AB = String
+  given ToString[AB] = ab => println(ab)
+
+  opaque type AC = String
+  given ToString[AC] {
+    def print(ac: AC): Unit = println(ac)
+  }
+}
+
+package B {
+  case class BA(text: String)
+  object BA {
+    given ToString[BA] = ba => println(ba.text)
+  }
+
+  opaque type BB = String
+  object BB {
+    given ToString[BB] = bb => println(bb)
+  }
+
+  opaque type BC = String
+  object BC {
+    given ToString[BC] {
+      def print(bc: BC): Unit = println(bc)
+    }
+  }
+}
+
+object Test {
+  val AA = summon[ToString[A.AA]] // error
+  val AB = summon[ToString[A.AB]] // error, used to compile
+  val AC = summon[ToString[A.AC]] // error
+
+  val BA = summon[ToString[B.BA]]
+  val BB = summon[ToString[B.BB]]
+  val BC = summon[ToString[B.BC]]
+}