Existential printing, plus more compiler testing infrastructure.

Direct compiler internals testing. It's really easy, you should probably
use it about 1000 times each. Look at the test:

  run/existentials-in-compiler.scala

The checkfile contains the (string representations of the) actual
existentials from the compiler to make sure they correspond properly to
the ones in the source.

Existentials were being printed with wildcards too freely; this has been
tightened up.

2 files changed, 239 insertions, 0 deletions

diff --git a/test/files/run/existentials-in-compiler.check b/test/files/run/existentials-in-compiler.check
new file mode 100644
index 0000000000..c8040a4cb1
--- /dev/null
+++ b/test/files/run/existentials-in-compiler.check
@@ -0,0 +1,156 @@
+abstract trait Bippy[A <: AnyRef,B] extends Object
+    extest.Bippy[_ <: AnyRef, _]
+
+abstract trait BippyBud[A <: AnyRef,B,C <: List[A]] extends Object
+    extest.BippyBud[A,B,C] forSome { A <: AnyRef; B; C <: List[A] }
+
+abstract trait BippyLike[A <: AnyRef,B <: List[A],This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends Object
+    extest.BippyLike[A,B,This] forSome { A <: AnyRef; B <: List[A]; This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B] }
+
+abstract trait Contra[-A >: AnyRef,-B] extends Object
+    extest.Contra[_ >: AnyRef, _]
+
+abstract trait ContraLike[-A >: AnyRef,-B >: List[A]] extends Object
+    extest.ContraLike[A,B] forSome { -A >: AnyRef; -B >: List[A] }
+
+abstract trait Cov01[+A <: AnyRef,+B] extends Object
+    extest.Cov01[_ <: AnyRef, _]
+
+abstract trait Cov02[+A <: AnyRef,B] extends Object
+    extest.Cov02[_ <: AnyRef, _]
+
+abstract trait Cov03[+A <: AnyRef,-B] extends Object
+    extest.Cov03[_ <: AnyRef, _]
+
+abstract trait Cov04[A <: AnyRef,+B] extends Object
+    extest.Cov04[_ <: AnyRef, _]
+
+abstract trait Cov05[A <: AnyRef,B] extends Object
+    extest.Cov05[_ <: AnyRef, _]
+
+abstract trait Cov06[A <: AnyRef,-B] extends Object
+    extest.Cov06[_ <: AnyRef, _]
+
+abstract trait Cov07[-A <: AnyRef,+B] extends Object
+    extest.Cov07[_ <: AnyRef, _]
+
+abstract trait Cov08[-A <: AnyRef,B] extends Object
+    extest.Cov08[_ <: AnyRef, _]
+
+abstract trait Cov09[-A <: AnyRef,-B] extends Object
+    extest.Cov09[_ <: AnyRef, _]
+
+abstract trait Cov11[+A <: AnyRef,+B <: List[_]] extends Object
+    extest.Cov11[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov12[+A <: AnyRef,B <: List[_]] extends Object
+    extest.Cov12[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov13[+A <: AnyRef,-B <: List[_]] extends Object
+    extest.Cov13[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov14[A <: AnyRef,+B <: List[_]] extends Object
+    extest.Cov14[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov15[A <: AnyRef,B <: List[_]] extends Object
+    extest.Cov15[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov16[A <: AnyRef,-B <: List[_]] extends Object
+    extest.Cov16[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov17[-A <: AnyRef,+B <: List[_]] extends Object
+    extest.Cov17[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov18[-A <: AnyRef,B <: List[_]] extends Object
+    extest.Cov18[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov19[-A <: AnyRef,-B <: List[_]] extends Object
+    extest.Cov19[_ <: AnyRef, _ <: List[_]]
+
+abstract trait Cov21[+A,+B] extends Object
+    extest.Cov21[_, _]
+
+abstract trait Cov22[+A,B] extends Object
+    extest.Cov22[_, _]
+
+abstract trait Cov23[+A,-B] extends Object
+    extest.Cov23[_, _]
+
+abstract trait Cov24[A,+B] extends Object
+    extest.Cov24[_, _]
+
+abstract trait Cov25[A,B] extends Object
+    extest.Cov25[_, _]
+
+abstract trait Cov26[A,-B] extends Object
+    extest.Cov26[_, _]
+
+abstract trait Cov27[-A,+B] extends Object
+    extest.Cov27[_, _]
+
+abstract trait Cov28[-A,B] extends Object
+    extest.Cov28[_, _]
+
+abstract trait Cov29[-A,-B] extends Object
+    extest.Cov29[_, _]
+
+abstract trait Cov31[+A,+B,C <: (A, B)] extends Object
+    extest.Cov31[A,B,C] forSome { +A; +B; C <: (A, B) }
+
+abstract trait Cov32[+A,B,C <: (A, B)] extends Object
+    extest.Cov32[A,B,C] forSome { +A; B; C <: (A, B) }
+
+abstract trait Cov33[+A,-B,C <: (A, _$10) forSome { type _$10 }] extends Object
+    extest.Cov33[A,B,C] forSome { +A; -B; C <: (A, _$10) forSome { type _$10 } }
+
+abstract trait Cov34[A,+B,C <: (A, B)] extends Object
+    extest.Cov34[A,B,C] forSome { A; +B; C <: (A, B) }
+
+abstract trait Cov35[A,B,C <: (A, B)] extends Object
+    extest.Cov35[A,B,C] forSome { A; B; C <: (A, B) }
+
+abstract trait Cov36[A,-B,C <: (A, _$11) forSome { type _$11 }] extends Object
+    extest.Cov36[A,B,C] forSome { A; -B; C <: (A, _$11) forSome { type _$11 } }
+
+abstract trait Cov37[-A,+B,C <: (_$12, B) forSome { type _$12 }] extends Object
+    extest.Cov37[A,B,C] forSome { -A; +B; C <: (_$12, B) forSome { type _$12 } }
+
+abstract trait Cov38[-A,B,C <: (_$13, B) forSome { type _$13 }] extends Object
+    extest.Cov38[A,B,C] forSome { -A; B; C <: (_$13, B) forSome { type _$13 } }
+
+abstract trait Cov39[-A,-B,C <: Tuple2[_, _]] extends Object
+    extest.Cov39[_, _, _ <: Tuple2[_, _]]
+
+abstract trait Cov41[+A >: Null,+B] extends Object
+    extest.Cov41[_ >: Null, _]
+
+abstract trait Cov42[+A >: Null,B] extends Object
+    extest.Cov42[_ >: Null, _]
+
+abstract trait Cov43[+A >: Null,-B] extends Object
+    extest.Cov43[_ >: Null, _]
+
+abstract trait Cov44[A >: Null,+B] extends Object
+    extest.Cov44[_ >: Null, _]
+
+abstract trait Cov45[A >: Null,B] extends Object
+    extest.Cov45[_ >: Null, _]
+
+abstract trait Cov46[A >: Null,-B] extends Object
+    extest.Cov46[_ >: Null, _]
+
+abstract trait Cov47[-A >: Null,+B] extends Object
+    extest.Cov47[_ >: Null, _]
+
+abstract trait Cov48[-A >: Null,B] extends Object
+    extest.Cov48[_ >: Null, _]
+
+abstract trait Cov49[-A >: Null,-B] extends Object
+    extest.Cov49[_ >: Null, _]
+
+abstract trait Covariant[+A <: AnyRef,+B] extends Object
+    extest.Covariant[_ <: AnyRef, _]
+
+abstract trait CovariantLike[+A <: AnyRef,+B <: List[A],+This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends Object
+    extest.CovariantLike[A,B,This] forSome { +A <: AnyRef; +B <: List[A]; +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B] }
+
diff --git a/test/files/run/existentials-in-compiler.scala b/test/files/run/existentials-in-compiler.scala
new file mode 100644
index 0000000000..e4f6920145
--- /dev/null
+++ b/test/files/run/existentials-in-compiler.scala
@@ -0,0 +1,83 @@
+import scala.tools.nsc._
+import scala.tools.partest.CompilerTest
+import scala.collection.{ mutable, immutable, generic }
+
+object Test extends CompilerTest {
+  import global._
+  import definitions._
+
+  def code = """
+package extest {
+  trait Bippy[A <: AnyRef, B] { }     // wildcards
+  trait BippyLike[A <: AnyRef, B <: List[A], This <: BippyLike[A, B, This] with Bippy[A, B]]  // no wildcards
+  trait BippyBud[A <: AnyRef, B, C <: List[A]]
+
+  trait Cov01[+A <: AnyRef, +B] { }
+  trait Cov02[+A <: AnyRef,  B] { }
+  trait Cov03[+A <: AnyRef, -B] { }
+  trait Cov04[ A <: AnyRef, +B] { }
+  trait Cov05[ A <: AnyRef,  B] { }
+  trait Cov06[ A <: AnyRef, -B] { }
+  trait Cov07[-A <: AnyRef, +B] { }
+  trait Cov08[-A <: AnyRef,  B] { }
+  trait Cov09[-A <: AnyRef, -B] { }
+  
+  trait Cov11[+A <: AnyRef, +B <: List[_]] { }
+  trait Cov12[+A <: AnyRef,  B <: List[_]] { }
+  trait Cov13[+A <: AnyRef, -B <: List[_]] { }
+  trait Cov14[ A <: AnyRef, +B <: List[_]] { }
+  trait Cov15[ A <: AnyRef,  B <: List[_]] { }
+  trait Cov16[ A <: AnyRef, -B <: List[_]] { }
+  trait Cov17[-A <: AnyRef, +B <: List[_]] { }
+  trait Cov18[-A <: AnyRef,  B <: List[_]] { }
+  trait Cov19[-A <: AnyRef, -B <: List[_]] { }
+  
+  trait Cov21[+A, +B] { }
+  trait Cov22[+A,  B] { }
+  trait Cov23[+A, -B] { }
+  trait Cov24[ A, +B] { }
+  trait Cov25[ A,  B] { }
+  trait Cov26[ A, -B] { }
+  trait Cov27[-A, +B] { }
+  trait Cov28[-A,  B] { }
+  trait Cov29[-A, -B] { }
+  
+  trait Cov31[+A, +B, C <: ((A, B))] { }
+  trait Cov32[+A,  B, C <: ((A, B))] { }
+  trait Cov33[+A, -B, C <: ((A, _))] { }
+  trait Cov34[ A, +B, C <: ((A, B))] { }
+  trait Cov35[ A,  B, C <: ((A, B))] { }
+  trait Cov36[ A, -B, C <: ((A, _))] { }
+  trait Cov37[-A, +B, C <: ((_, B))] { }
+  trait Cov38[-A,  B, C <: ((_, B))] { }
+  trait Cov39[-A, -B, C <: ((_, _))] { }
+  
+  trait Cov41[+A >: Null, +B] { }
+  trait Cov42[+A >: Null,  B] { }
+  trait Cov43[+A >: Null, -B] { }
+  trait Cov44[ A >: Null, +B] { }
+  trait Cov45[ A >: Null,  B] { }
+  trait Cov46[ A >: Null, -B] { }
+  trait Cov47[-A >: Null, +B] { }
+  trait Cov48[-A >: Null,  B] { }
+  trait Cov49[-A >: Null, -B] { }
+
+  trait Covariant[+A <: AnyRef, +B] { }
+  trait CovariantLike[+A <: AnyRef, +B <: List[A], +This <: CovariantLike[A, B, This] with Covariant[A, B]]
+
+  trait Contra[-A >: AnyRef, -B] { }
+  trait ContraLike[-A >: AnyRef, -B >: List[A]]
+}
+  """
+
+  def check(source: String, unit: global.CompilationUnit) = {
+    getRequiredModule("extest").moduleClass.info.decls.toList.filter(_.isType).map(_.initialize).sortBy(_.name.toString) foreach { clazz =>
+      afterTyper {
+        clazz.info
+        println(clazz.defString)
+        println("    " + classExistentialType(clazz) + "\n")
+      }
+    }
+    true
+  }
+}