Fix for SI-4744, another variety of cycle.

I threw this in with the previous commit behind -Ybreak-cycles, but
this one is much less sketchy. Explanation: have to handle f-bounds
more deftly. Namers forces lower bounds to prevent recursion in
that direction, but a light touch is required to handle these two
situations differently:

  // This is a cyclic type parameter - an error is correct
  class A[T <: Comparable[_ <: T]]

  // This is not cyclic - it flips the arrow
  class B[T <: Comparable[_ >: T]]

Long have I been haunted by the knowledge that you can
write class B in java, but not in scala:

  public class B<T extends Comparable<? super T>> {}

It's over! We've achieved parity with java.

1 files changed, 3 insertions, 3 deletions

diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index d506a43829..7d0c05bc81 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -1398,9 +1398,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       if (!isInitialized) info
       this
     }
-    def maybeInitialize: this.type = {
-      try initialize
-      catch { case _: CyclicReference => debuglog("Encountering cycle in maybe-initialization of $this") ; this }
+    def maybeInitialize = {
+      try   { initialize ; true }
+      catch { case _: CyclicReference => debuglog("Hit cycle in maybeInitialize of $this") ; false }
     }
 
     /** Called when the programmer requests information that might require initialization of the underlying symbol.