Also include companions of prefixes in implicit scope

In that way, we include all of the implicit scope of Scala 2, except
for package objects. The idea is that everything that is reasonable
should be included in the implicit scope.

Package objects were excluded since they had a dual purpose:

 1. as a way to define implicits that are in scope for a whole project
 2. as a prefix for implicits of all types coming out of that project

It's often that one wants only (1) but then is surprised to also get (2).

# Conflicts:
#	compiler/src/dotty/tools/dotc/typer/Implicits.scala
#	tests/pos/i9103.scala

Author: odersky

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

@@ -500,13 +500,6 @@ trait ImplicitRunInfo:
       private var parts: mutable.LinkedHashSet[Type] = _
       private val partSeen = TypeHashSet()
 
-      def traversePrefix(pre: Type): Unit = pre match
-        case pre: TermRef =>
-          if migrateTo3 then traverse(pre.info)
-          traversePrefix(pre.prefix)
-        case _ =>
-          traverse(pre)
-
       def traverse(t: Type) =
         if partSeen.contains(t) then ()
         else if implicitScopeCache.contains(t) then parts += t
@@ -516,13 +509,13 @@ trait ImplicitRunInfo:
             case t: TypeRef =>
               if isAnchor(t.symbol) then
                 parts += t
-                traversePrefix(t.prefix)
+                traverse(t.prefix)
               else
                 traverse(t.underlying)
             case t: TermRef =>
               if !isExcluded(t.symbol) then
                 traverse(t.info)
-                traversePrefix(t.prefix)
+                traverse(t.prefix)
             case t: ThisType if t.cls.is(Module) && t.cls.isStaticOwner =>
               traverse(t.cls.sourceModule.termRef)
             case t: ConstantType =>

tests/pos/i9103.scala

@@ -0,0 +1,28 @@
+object a:
+  type Foo[T]
+  given as Foo[Unit] = ???
+
+val b = a
+
+def test1 = summon[b.Foo[Unit]]  // no ambiguity between b.given_Foo and a.given_Foo
+
+val n: Long = 1
+val total: BigInt = 2
+val remainder = n % identity(total)  // object BigInt is in implicit scope of `total.type`
+
+trait Show[T] {def show(a: T): String}
+
+object S extends LowPriorityInstances {
+  class Permissions
+}
+
+sealed trait LowPriorityInstances
+object LowPriorityInstances {
+  given S.Permissions = ???
+  given Show[S.Permissions] = _ => "perms"
+}
+
+def test =
+  println(implicitly[S.Permissions])      // companions of base classes of S are in implicit scope
+  println(implicitly[Show[S.Permissions]])
+