Handle case where typevar instance is fully determined

It's possible that a type parameter in a constraint gets instantiated via
a unification operation. In that case, the type parameter does not have
a TypeBounds instance associated with it, so is not considered to be
contained in the constraint. But it must still be possible to instantiate
a type variable corresponding to this parameter.

Test case in collection strawman: `List.empty ++ List.empty`.

Author: odersky

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

@@ -222,11 +222,16 @@ trait ConstraintHandling {
         }
       }
     }
-    assert(constraint.contains(param))
-    val bound = if (fromBelow) constraint.fullLowerBound(param) else constraint.fullUpperBound(param)
-    val inst = avoidParam(bound)
-    typr.println(s"approx ${param.show}, from below = $fromBelow, bound = ${bound.show}, inst = ${inst.show}")
-    inst
+    constraint.entry(param) match {
+      case bounds: TypeBounds =>
+        val bound = if (fromBelow) constraint.fullLowerBound(param) else constraint.fullUpperBound(param)
+        val inst = avoidParam(bound)
+        typr.println(s"approx ${param.show}, from below = $fromBelow, bound = ${bound.show}, inst = ${inst.show}")
+        inst
+      case inst =>
+        assert(inst.exists, i"$param not in $constraint")
+        inst
+    }
   }
 
   /** The instance type of `param` in the current constraint (which contains `param`).

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

@@ -160,7 +160,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     val origin = tvar.origin
     val entries = boundsMap(origin.binder)
     val pnum = origin.paramNum
-    entries != null && isBounds(entries(pnum)) && (typeVar(entries, pnum) eq tvar)
+    entries != null && entries(pnum).exists && (typeVar(entries, pnum) eq tvar)
   }
 
   private def isBounds(tp: Type) = tp.isInstanceOf[TypeBounds]
@@ -507,19 +507,19 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       (ps1 /: ps2)((ps1, p2) => if (ps1.contains(p2)) ps1 else p2 :: ps1)
 
     def mergeEntries(e1: Type, e2: Type): Type = e1 match {
-        case e1: TypeBounds =>
-          e2 match {
-            case e2: TypeBounds => e1 & e2
-            case _ if e1 contains e2 => e2
-            case _ => mergeError
-          }
-        case tv1: TypeVar =>
-          e2 match {
-            case tv2: TypeVar if tv1.instanceOpt eq tv2.instanceOpt => e1
-            case _ => mergeError
-          }
-        case _ if e1 eq e2 => e1
-        case _ => mergeError
+      case e1: TypeBounds =>
+        e2 match {
+          case e2: TypeBounds      => e1 & e2
+          case _ if e1 contains e2 => e2
+          case _                   => mergeError
+        }
+      case tv1: TypeVar =>
+        e2 match {
+          case tv2: TypeVar if tv1.instanceOpt eq tv2.instanceOpt => e1
+          case _ => mergeError
+        }
+      case _ if e1 eq e2 => e1
+      case _ => mergeError
     }
 
     def mergeError = throw new AssertionError(i"cannot merge $this with $other")
@@ -611,7 +611,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
   override def toString: String = {
     def entryText(tp: Type): String = tp match {
       case tp: TypeBounds => tp.toString
-      case _ =>" := " + tp
+      case _ => " := " + tp
     }
     val constrainedText =
       " constrained types = " + domainLambdas.mkString("\n")