Fix tests

 - some tests do deeper subtype recursions, need to be run without -Yno-deep-subtypes
 - some tests have different outcomes, but the new outcome looks sensible.
 - some new tests

Author: odersky

compiler/test/dotc/tests.scala

@@ -104,8 +104,8 @@ class tests extends CompilerTest {
   val typerDir  = dotcDir + "typer/"
   val libDir = "../library/src/"
 
-  def dottyBootedLib = compileDir(libDir, ".", List("-deep", "-Ycheck-reentrant", "-strict") ::: defaultOptions)(allowDeepSubtypes) // note the -deep argument
-  def dottyDependsOnBootedLib = compileDir(dottyDir, ".", List("-deep", "-Ycheck-reentrant") ::: defaultOptions)(allowDeepSubtypes) // note the -deep argument
+  def dottyBootedLib = compileDir(libDir, ".", List("-deep", "-Ycheck-reentrant", "-strict"))(allowDeepSubtypes) // note the -deep argument
+  def dottyDependsOnBootedLib = compileDir(dottyDir, ".", List("-deep", "-Ycheck-reentrant"))(allowDeepSubtypes) // note the -deep argument
 
   @Before def cleanup(): Unit = {
     // remove class files from stdlib and tests compilation
@@ -194,7 +194,6 @@ class tests extends CompilerTest {
   @Test def neg_i1240 = compileFile(negCustomArgs, "i1240")(allowDoubleBindings)
   @Test def neg_i2002 = compileFile(negCustomArgs, "i2002")(allowDoubleBindings)
   @Test def neg_valueclasses_doubledefs = compileFile(negCustomArgs, "valueclasses-doubledefs")(allowDoubleBindings)
-  @Test def neg_valueclasses_doubledefs2 = compileFile(negCustomArgs, "valueclasses-doubledefs2")(allowDoubleBindings)
   @Test def neg_valueclasses_pavlov = compileFile(negCustomArgs, "valueclasses-pavlov")(allowDoubleBindings)
   @Test def neg_trailingUnderscore = compileFile(negCustomArgs, "trailingUnderscore", args = "-strict" :: Nil)
 

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -27,6 +27,11 @@ class CompilationTests extends ParallelTesting {
 
   // Positive tests ------------------------------------------------------------
 
+  // @Test  // enable to test compileStdLib separately with detailed stats
+  def compileStdLib: Unit = {
+    compileList("compileStdLib", StdLibSources.whitelisted, scala2Mode.and("-migration", "-Yno-inline", "-Ydetailed-stats"))
+  }.checkCompile()
+
   @Test def compilePos: Unit = {
     compileList("compileStdLib", StdLibSources.whitelisted, scala2Mode.and("-migration", "-Yno-inline")) +
     compileDir("../collection-strawman/src/main", defaultOptions) +
@@ -85,6 +90,7 @@ class CompilationTests extends ParallelTesting {
     compileFilesInDir("../tests/new", defaultOptions) +
     compileFilesInDir("../tests/pos-scala2", scala2Mode) +
     compileFilesInDir("../tests/pos", defaultOptions) +
+    compileFilesInDir("../tests/pos-deep-subtype", allowDeepSubtypes) +
     compileFile(
       // succeeds despite -Xfatal-warnings because of -nowarn
       "../tests/neg/customArgs/xfatalWarnings.scala",

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -62,6 +62,7 @@ object TestConfiguration {
     "-Ytest-pickler",
     "-Yprintpos"
   )
+  val picklingOptionsAllowDeepSubTypes = picklingOptions diff Array("-Yno-deep-subtypes")
   val scala2Mode = defaultOptions ++ Array("-language:Scala2")
   val explicitUTF8 = defaultOptions ++ Array("-encoding", "UTF8")
   val explicitUTF16 = defaultOptions ++ Array("-encoding", "UTF16")

tests/neg/leak-type.scala

@@ -1,13 +1,13 @@
 trait A {
-  private type Foo = Int
+  private class Foo
 
 
-  class Inner[T <: Foo] { // error: non-private type T refers to private type Foo in its type signature
+  class Inner[T <: Foo] { // error: non-private type T refers to private class Foo in its type signature
     def get: T = ???
   }
 }
 class B extends A {
   def foo(x: Inner[_]): Unit = {
-    val a = x.get // error: cannot resolve reference to type B(B.this).Foo
+    val a = x.get
   }
 }

tests/neg/customArgs/valueclasses-doubledefs2.scala renamed to tests/neg/valueclasses-doubledefs2.scala

@@ -7,4 +7,4 @@ trait B {
   def apply(x: Meter) = x.toString
 }
 
-object Test extends A with B // error: double def
+object Test extends A with B // error: double definition

tests/pos/sets.scala renamed to tests/pos-deep-subtype/sets.scala

@@ -0,0 +1,12 @@
+trait Foo[-T]
+
+trait Bar[-T] extends Foo[T]
+
+object Test {
+  implicit val fa: Foo[Any] = ???
+  implicit val ba: Bar[Int] = ???
+
+  def test: Unit = {
+    implicitly[Foo[Int]]
+  }
+}

tests/pos/i2974.scala

@@ -0,0 +1,8 @@
+object A {
+  def fun[E >: B](a: A[E]): E => Unit = ???
+  val x = fun(new A[C])
+}
+class B extends C
+class C
+
+class A[-X >: B]