Added sanity check to lub calculation to preven...

Added sanity check to lub calculation to prevent invalid lubs from
emerging. The underlying cause of said lubs is that higher-order
type parameters are not handled correctly: this is why the issue
is seen so frequently in the collections. See pending test
pending/pos/those-kinds-are-high.scala for a demonstration. Until that's
fixed, we can at least raise the bar a bit.

Closes #2094, #2322, #4501. Also, some test cases in neg have been
promoted into working programs: #2179, #3774. (They're not in neg for
the "shouldn't work" reason, but out of despair.)

In some cases, such as the original reported ticket in #3528, this
only pushes the problem downfield: it still fails due to inferred type
parameters not conforming to bounds. I believe a similar issue with
higher-order type parameters underlies that.

Look at how far this takes us though. All kinds of stuff which did not
work, now works. None of these even compiled until now:

  scala> :type List(mutable.Map(1 -> 1), immutable.Map(1 -> 1))
  List[scala.collection.Map[Int,Int]]

  scala> :type Set(List(1), mutable.Map(1 -> 1))
  scala.collection.Set[Iterable[Any] with PartialFunction[Int,Int]]

  scala> :type Stream(List(1), Set(1), 1 to 5)
  Stream[Iterable[Int] with Int => AnyVal{def getClass(): Class[_ >: Int with Boolean <: AnyVal]}]

  scala> :type Map(1 -> (1 to 10), 2 -> (1 to 10).toList)
  scala.collection.immutable.Map[Int,scala.collection.immutable.Seq[Int]
  ]

PERFORMANCE: compiling quick.lib and quick.comp, this patch results in
an extra 27 subtype tests. Total. Time difference too small to measure.
However to be on the safe side I made it really easy to disable.

  private final val verifyLubs = true // set to false

Review by moors, odersky.

1 files changed, 31 insertions, 0 deletions

diff --git a/test/files/pos/bug2094.scala b/test/files/pos/bug2094.scala
new file mode 100644
index 0000000000..ff142117b2
--- /dev/null
+++ b/test/files/pos/bug2094.scala
@@ -0,0 +1,31 @@
+object Test extends App {
+  // compiles:
+  Map[Int, Value](
+    0 -> KnownType(classOf[Object]),
+    1 -> UnknownValue())
+
+  // does not compile:
+  Map(
+    0 -> KnownType(classOf[Object]),
+    1 -> UnknownValue())
+
+  // Experiment.scala:10: error: type mismatch;
+  //  found   : (Int, KnownType)
+  //  required: (Int, Product with Value{def getType: Option[java.lang.Class[_$$2]]}) where type _$$2
+  //     0 -> KnownType(classOf[Object]),
+  //       ^
+  // one error found
+}
+sealed trait Value {
+  def getType: Option[Class[_]]
+}
+
+case class UnknownValue() extends Value {
+  def getType = None
+  // compiles if changed to:
+  // def getType: Option[Class[_]] = None
+}
+
+case class KnownType(typ: Class[_]) extends Value {
+  def getType = Some(typ)
+}
\ No newline at end of file