Fix implicit scope caching bug

The issue is subtle: the `tp` in scope in `def ofTypeImplicits` is the
`tp` passed to the top-level `implicitScope` method, not the `tp` passed
to the recursively called `iscope`, this means that before this commit,
all intermediate `OfTypeImplicit` scopes cached while computing an
implicit scope had their `tp` field incorrectly set, which means that we
could miss implicits in later implicit searches.

Note that the `implicit_cache.scala` test worked before this commit
because of the restrictions on caching that exist since
b8b0f38, it is included anyway because
our caching strategy might change in the future.

Author: smarter

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

@@ -338,8 +338,6 @@ trait ImplicitRunInfo { self: RunInfo =>
       }
     }
 
-    def ofTypeImplicits(comps: TermRefSet) = new OfTypeImplicits(tp, comps)(ctx)
-
    /** The implicit scope of type `tp`
      *  @param isLifted    Type `tp` is the result of a `liftToClasses` application
      */
@@ -349,9 +347,12 @@ trait ImplicitRunInfo { self: RunInfo =>
         ctx.typerState.ephemeral = false
         try {
           val liftedTp = if (isLifted) tp else liftToClasses(tp)
-          val result =
-            if (liftedTp ne tp) iscope(liftedTp, isLifted = true)
-            else ofTypeImplicits(collectCompanions(tp))
+          val refs =
+            if (liftedTp ne tp)
+              iscope(liftedTp, isLifted = true).companionRefs
+            else
+              collectCompanions(tp)
+          val result = new OfTypeImplicits(tp, refs)(ctx)
           if (ctx.typerState.ephemeral) record("ephemeral cache miss: implicitScope")
           else if (cacheResult) implicitScopeCache(tp) = result
           result

tests/pos/implicit_cache.scala

@@ -0,0 +1,16 @@
+class A
+object A {
+  implicit def theA: A = new A
+}
+class Foo[T]
+object Foo {
+  implicit def theFoo: Foo[A] = new Foo[A]
+}
+
+object Test {
+  def getFooA(implicit foo: Foo[A]) = foo
+  def getA(implicit a: A) = a
+
+  getFooA
+  getA
+}