Merge pull request scala#6068 from milessabin/topic/si-9122

Only cache ImplicitInfo erroneous status in isCyclicOrErroneous.

Author: retronym

src/compiler/scala/tools/nsc/typechecker/Implicits.scala

@@ -207,21 +207,24 @@ trait Implicits {
    */
   class ImplicitInfo(val name: Name, val pre: Type, val sym: Symbol) {
     private var tpeCache: Type = null
-    private var isCyclicOrErroneousCache: TriState = TriState.Unknown
+    private var isErroneousCache: TriState = TriState.Unknown
 
     /** Computes member type of implicit from prefix `pre` (cached). */
     def tpe: Type = {
       if (tpeCache eq null) tpeCache = pre.memberType(sym)
       tpeCache
     }
 
-    def isCyclicOrErroneous: Boolean = {
-      if (!isCyclicOrErroneousCache.isKnown) isCyclicOrErroneousCache = computeIsCyclicOrErroneous
-      isCyclicOrErroneousCache.booleanValue
-    }
+    def isCyclicOrErroneous: Boolean =
+      if(sym.hasFlag(LOCKED)) true
+      else {
+        if(!isErroneousCache.isKnown)
+          isErroneousCache = computeErroneous
+        isErroneousCache.booleanValue
+      }
 
-    private[this] final def computeIsCyclicOrErroneous =
-      try sym.hasFlag(LOCKED) || containsError(tpe)
+    private[this] final def computeErroneous =
+      try containsError(tpe)
       catch { case _: CyclicReference => true }
 
     var useCountArg: Int = 0

test/files/pos/t9122.scala

@@ -0,0 +1,8 @@
+class X[A](a: A)
+object Test {
+  implicit val ImplicitBoolean: Boolean = true
+  def local = {
+    implicit object X extends X({ def local2 = implicitly[Boolean] ; "" })
+    implicitly[X[String]]
+  }
+}

test/files/run/implicit-caching.scala

@@ -0,0 +1,25 @@
+trait Foo[T]
+
+trait FooSub[T] extends Foo[T] {
+  type Super = Foo[T]
+}
+
+object FooSub {
+  implicit def fooSub[T](implicit ft: Bar[T]): FooSub[T] =
+    new FooSub[T] {}
+}
+
+trait Bar[T]
+
+class Quux
+
+object Quux {
+  implicit val barQuux: Bar[Quux] = new Bar[Quux] {}
+
+  val fooSubQuux = implicitly[FooSub[Quux]]
+  implicit val fooQuux: fooSubQuux.Super = fooSubQuux
+}
+
+object Test extends App {
+  implicitly[Foo[Quux]]
+}