Fix for TypeVar instantiation.

In an effort to reduce the enormous amount of duplication
which now exists among methods which attempt to deduce something
about the relationship between two types, a sampling (and only
a sampling - this might not even be half of them) given here:

  def isAsSpecific(ftpe1: Type, ftpe2: Type): Boolean
  def isCompatibleByName(tp: Type, pt: Type): Boolean
  def isConservativelyCompatible(tp: Type, pt: Type): Boolean
  def isConsistent(tp1: Type, tp2: Type): Boolean
  def isDifferentType(tp1: Type, tp2: Type): Boolean
  def isDifferentTypeConstructor(tp1: Type, tp2: Type): Boolean
  def isDistinguishableFrom(t1: Type, t2: Type): Boolean
  def isNeverSubType(tp1: Type, tp2: Type): Boolean
  def isNumericSubType(tp1: Type, tp2: Type): Boolean
  def isPlausiblyCompatible(tp: Type, pt: Type): Boolean
  def isPopulated(tp1: Type, tp2: Type): Boolean
  def isSameType(tp1: Type, tp2: Type): Boolean
  def isSameType2(tp1: Type, tp2: Type): Boolean
  def isSubType(tp1: Type, tp2: Type): Boolean
  def isWeakSubType(tp1: Type, tp2: Type): Boolean
  def isWeaklyCompatible(tp: Type, pt: Type): Boolean
  def matches(tpe1: Type, tpe2: Type): Boolean
  def overlaps(tp1: Type, tp2: Type): Boolean
  def typesConform(tp: Type, pt: Type): Boolean

I began pulling a thread left by moors in isPopulated:

  need to investgate why this can't be made symmetric --
  neg/gadts1 fails, and run/existials also.

Followed that to this code in TypeVar:

  val newInst = wildcardToTypeVarMap(tp)
  (constr isWithinBounds newInst) && { setInst(tp); true }
                                        -------^

That was the obstacle to symmetry, because it creates a
cycle in e.g. run/existentials.  Kept pulling the string,
came back to my own comment of long ago:

  !!! Is it somehow guaranteed that this will not break
  under nesting? In general one has to save and restore
  the contents of the field...

Decided that uncertainty could no longer be tolerated.
Unless it can be proven somehow that there will never be
crosstalk among the save/suspension points, we should do
it this way even if nothing demands it yet.

What's in this commit:

 - Made isPopulated symmetric.
 - Made setInst resistant to TypeVar cycles.
 - Fixed above mentioned bug in registerTypeEquality.
 - Added some rigor to the suspension/unsuspension of TypeVars
   so it will not break under nesting.
 - Recovered pos/t0851.scala from its deletion.

4 files changed, 26 insertions, 9 deletions

diff --git a/test/files/neg/gadts1.check b/test/files/neg/gadts1.check
index 44d2b114d6..a61231a27a 100644
--- a/test/files/neg/gadts1.check
+++ b/test/files/neg/gadts1.check
@@ -1,8 +1,3 @@
-gadts1.scala:15: error: type mismatch;
- found   : Test.Double
- required: a
-    case NumTerm(n) => c.x = Double(1.0) 
-                                   ^
 gadts1.scala:20: error: class Cell of type Test.Cell does not take type parameters.
     case Cell[a](x: Int) => c.x = 5
              ^
@@ -11,4 +6,4 @@ gadts1.scala:20: error: type mismatch;
  required: a
     case Cell[a](x: Int) => c.x = 5
                                   ^
-three errors found
+two errors found
diff --git a/test/files/neg/patmat-type-check.check b/test/files/neg/patmat-type-check.check
index 721217c314..fedac3b746 100644
--- a/test/files/neg/patmat-type-check.check
+++ b/test/files/neg/patmat-type-check.check
@@ -1,12 +1,27 @@
 patmat-type-check.scala:11: warning: fruitless type test: a value of type Test.Bop4[T] cannot also be a Seq[A]
   def s3[T](x: Bop4[T]) = x match { case Seq('b', 'o', 'b') => true }
                                             ^
+patmat-type-check.scala:11: error: pattern type is incompatible with expected type;
+ found   : Seq[A]
+ required: Test.Bop4[T]
+  def s3[T](x: Bop4[T]) = x match { case Seq('b', 'o', 'b') => true }
+                                            ^
 patmat-type-check.scala:15: warning: fruitless type test: a value of type Test.Bop5[_$1,T1,T2] cannot also be a Seq[A]
   def s4[T1, T2](x: Bop5[_, T1, T2]) = x match { case Seq('b', 'o', 'b') => true }
                                                          ^
+patmat-type-check.scala:15: error: pattern type is incompatible with expected type;
+ found   : Seq[A]
+ required: Test.Bop5[_$1,T1,T2] where type _$1
+  def s4[T1, T2](x: Bop5[_, T1, T2]) = x match { case Seq('b', 'o', 'b') => true }
+                                                         ^
 patmat-type-check.scala:19: warning: fruitless type test: a value of type Test.Bop3[T] cannot also be a Seq[A]
   def f4[T](x: Bop3[T]) = x match { case Seq('b', 'o', 'b') => true }
                                             ^
+patmat-type-check.scala:19: error: pattern type is incompatible with expected type;
+ found   : Seq[A]
+ required: Test.Bop3[T]
+  def f4[T](x: Bop3[T]) = x match { case Seq('b', 'o', 'b') => true }
+                                            ^
 patmat-type-check.scala:22: error: scrutinee is incompatible with pattern type;
  found   : Seq[A]
  required: String
@@ -28,4 +43,4 @@ patmat-type-check.scala:30: error: scrutinee is incompatible with pattern type;
   def f4[T](x: Bop3[Char]) = x match { case Seq('b', 'o', 'b') => true } // fail
                                                ^
 three warnings found
-four errors found
+7 errors found
diff --git a/test/files/neg/t3015.check b/test/files/neg/t3015.check
index 6948392bb0..4a03c940f4 100644
--- a/test/files/neg/t3015.check
+++ b/test/files/neg/t3015.check
@@ -3,4 +3,7 @@ t3015.scala:7: error: scrutinee is incompatible with pattern type;
  required: String
   val b(foo) = "foo" 
        ^
-one error found
+error: type mismatch;
+ found   : _$1
+ required: String
+two errors found
diff --git a/test/files/neg/unchecked-impossible.check b/test/files/neg/unchecked-impossible.check
index 75fc390fa8..d150a5a853 100644
--- a/test/files/neg/unchecked-impossible.check
+++ b/test/files/neg/unchecked-impossible.check
@@ -1,6 +1,10 @@
 unchecked-impossible.scala:5: warning: fruitless type test: a value of type T2[Int,Int] cannot also be a Seq[A]
     case Seq(x) =>
             ^
-error: No warnings can be incurred under -Xfatal-warnings.
+unchecked-impossible.scala:5: error: pattern type is incompatible with expected type;
+ found   : Seq[A]
+ required: T2[Int,Int]
+    case Seq(x) =>
+            ^
 one warning found
 one error found