Fix #536 again

Test case was extended and several fixes were necessary to make it pass.

Author: odersky

compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala

@@ -312,7 +312,12 @@ trait ConstraintHandling {
   /** The current bounds of type parameter `param` */
   final def bounds(param: TypeParamRef): TypeBounds = {
     val e = constraint.entry(param)
-    if (e.exists) e.bounds else param.binder.paramInfos(param.paramNum)
+    if (e.exists) e.bounds
+    else {
+      val pinfos = param.binder.paramInfos
+      if (pinfos != null) pinfos(param.paramNum) // pinfos == null happens in pos/i536.scala
+      else TypeBounds.empty
+    }
   }
 
   /** Add type lambda `tl`, possibly with type variables `tvars`, to current constraint

compiler/src/dotty/tools/dotc/core/TypeApplications.scala

@@ -447,7 +447,7 @@ class TypeApplications(val self: Type) extends AnyVal {
         typr.println(i"normalize arg $arg for $tparam in $self app $args%, %, pbounds, = $pbounds")
         if (v > 0) hi & pbounds.hiBound
         else if (v < 0) lo | pbounds.loBound
-        else arg & pbounds
+        else arg recoverable_& pbounds
       case _ => arg
     }
 

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -575,19 +575,7 @@ object Types {
             if (rinfo.isAlias) rinfo
             else if (pdenot.info.isAlias) pdenot.info
             else if (ctx.pendingMemberSearches.contains(name)) pdenot.info safe_& rinfo
-            else
-              try pdenot.info & rinfo
-              catch {
-                case ex: CyclicReference =>
-                  // ??? can this still happen? ???
-                  // happens for tests/pos/sets.scala. findMember is called from baseTypeRef.
-                  // The & causes a subtype check which calls baseTypeRef again with the same
-                  // superclass. In the observed case, the superclass was Any, and
-                  // the special shortcut for Any in derivesFrom was as yet absent. To reproduce,
-                  // remove the special treatment of Any in derivesFrom and compile
-                  // sets.scala.
-                  pdenot.info safe_& rinfo
-              }
+            else pdenot.info recoverable_& rinfo
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         } else {
           pdenot & (
@@ -867,17 +855,29 @@ object Types {
 
     /** Safer version of `&`.
      *
-     *  This version does not simplify the upper bound of the intersection of
+     *  This version does not simplify the bounds of the intersection of
      *  two TypeBounds. The simplification done by `&` requires subtyping checks
      *  which may end up calling `&` again, in most cases this should be safe
      *  but because of F-bounded types, this can result in an infinite loop
      *  (which will be masked unless `-Yno-deep-subtypes` is enabled).
+     *  pos/i536 demonstrates that the infinite loop can also invole lower bounds.wait
      */
     def safe_& (that: Type)(implicit ctx: Context): Type = (this, that) match {
-      case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) => TypeBounds(lo1 | lo2, AndType(hi1, hi2))
+      case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) => TypeBounds(OrType(lo1, lo2), AndType(hi1, hi2))
       case _ => this & that
     }
 
+    /** `this & that`, but handle CyclicReferences by falling back to `safe_&`.
+     */
+    def recoverable_&(that: Type)(implicit ctx: Context): Type =
+      try this & that
+      catch {
+        case ex: CyclicReference => this safe_& that
+          // A test case where this happens is tests/pos/i536.scala.
+          // The & causes a subtype check which calls baseTypeRef again with the same
+          // superclass.
+      }
+
     def | (that: Type)(implicit ctx: Context): Type = track("|") {
       ctx.typeComparer.lub(this, that)
     }

tests/pos/i536.scala

@@ -1,3 +1,12 @@
+trait Comp[T]
+trait Coll[T]
+class C extends Comp[C]
 object Max {
+  def max[M <: Comp[_ >: M]](x: Coll[_ <: M]): M = ???
+  def max[M](x: Coll[_ <: M], cmp: Object): M = ???
+  val xs: Coll[C] = ???
+  val m1 = max(xs)
+  val m2 = max(null)
+
   java.util.Collections.max(null)
 }