More uniform treatment of package objects

  - Introduce `Symbol#packageObject` and `Type#packageObject`
    to lookup the member package object of a package class/module,
    and use this far and wide.
  - Replace the overly complicated (and still buggy) implementation
    of `Context#isInPackageObject` with a one liner. The simplifying
    insight is that if we select a symbol from a package prefix
    that does not own that symbol, it *must* have really been
    selected from the package object.
  - Change implicit search to use the cache in
    `ModuleSymbol#implicitMembers` via `Type#implicitMembers`,
    which lets the client code read more naturally.

Fixes a bug with `adapt::insertApply` that Adriaan spotted in a feat
of lateral thinking. This is tested in t8862b.scala. alladin763.scala
adds the test case from the bug originally remedied by `insertApply`
to check we haven't regressed.

1 files changed, 6 insertions, 12 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 2fab4557bd..e2ad578252 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -1012,18 +1012,12 @@ trait Implicits {
               }
             case None =>
               if (pre.isStable && !pre.typeSymbol.isExistentiallyBound) {
-                val companion =
-                  if (sym.isPackageClass) sym.info.member(nme.PACKAGE) //companionSymbolOf(sym.member, context)
-                  else companionSymbolOf(sym, context)
-                companion.moduleClass match {
-                  case mc: ModuleClassSymbol =>
-                    val pre1 = if (mc.isPackageObjectClass) mc.typeOfThis else singleType(pre, companion)
-                    val infos =
-                      for (im <- mc.implicitMembers.toList) yield new ImplicitInfo(im.name, pre1, im)
-                    if (infos.nonEmpty)
-                      infoMap += (sym -> infos)
-                  case _ =>
-                }
+                val pre1 =
+                  if (sym.isPackageClass) sym.packageObject.typeOfThis
+                  else singleType(pre, companionSymbolOf(sym, context))
+                val infos = pre1.implicitMembers.iterator.map(mem => new ImplicitInfo(mem.name, pre1, mem)).toList
+                if (infos.nonEmpty)
+                  infoMap += (sym -> infos)
               }
               val bts = tp.baseTypeSeq
               var i = 1