Dependent method tests

Author: odersky

tests/pending/pos/depmet_implicit_oopsla_zipwith.scala renamed to tests/disabled/structural-type/pos/depmet_implicit_oopsla_zipwith.scala

@@ -17,13 +17,18 @@ object Test{
     }
   }
 
+  import ZipWith._
+
   trait ZipWith[S] {
     type T
     def zipWith : S => T = sys.error("")
   }
 
   // bug: inferred return type = (Stream[A]) => java.lang.Object with Test.ZipWith[B]{type T = Stream[B]}#T
   // this seems incompatible with vvvvvvvvvvvvvvvvvvvvvv   -- #3731
-  def map[A,B](f : A => B)   /* : Stream[A] => Stream[B]*/ = ZipWith(f)
-  val tst: Stream[Int] = map{x: String => x.length}(Stream("a"))
+  def map1[A,B](f : A => B) = ZipWith(f)(SuccZipWith) // this typechecks but fails in -Ycheck:first
+  val tst1: Stream[Int] = map1[String, Int]{x: String => x.length}.apply(Stream("a"))
+
+  def map2[A,B](f : A => B) = ZipWith(f) // this finds ZeroZipWith where scalac finds SuccZipWith and fails typechecking in the next line.
+  val tst2: Stream[Int] = map2{x: String => x.length}.apply(Stream("a"))
 }

tests/pending/pos/depmet_implicit_norm_ret.scala

@@ -0,0 +1,7 @@
+object Test {
+  trait T { type X; val x: X }
+  implicit def f(x: T): x.X = x.x
+  val t = new T { type X = String; val x = "" }
+  val x: String = t
+  val uy: String = f(t)
+}

tests/pos/dependent-implicits.scala

@@ -0,0 +1,15 @@
+trait A {
+  type T
+}
+
+object O {
+  implicit def b(implicit x: A): x.T = error("")
+}
+
+class Test {
+  import O._
+  implicit val a: A = new A {}
+  implicitly[a.T]       // works
+
+  implicitly[a.T](b(a)) // works
+}