New tests

Author: odersky

tests/pending/neg/i7820.scala

@@ -0,0 +1 @@
+object A { type F[X >: F, Y] }

tests/pending/pos/i7745.scala

@@ -0,0 +1,3 @@
+trait F[x]
+implicit def foo[f[_], y, x <: f[y]](implicit ev: F[y]): F[x] = ???
+val test = implicitly

tests/pending/pos/i7778.scala

@@ -0,0 +1,5 @@
+object Example extends App {
+
+  final case class Foo[A](run: (given A) => Int)
+
+}

tests/pos/consume.scala

@@ -0,0 +1,57 @@
+object Test1 with
+  def consume(xs: List[Int], limit: Int): List[Int] = xs match
+    case x :: xs1 if limit > 0 => consume(xs1, limit - x)
+    case _ => xs
+
+object Test2 {
+  import scala.math.Numeric
+  import scala.math.Numeric.Implicits._
+  import scala.math.Ordering.Implicits._
+
+  def consume[T: Numeric](xs: List[T], limit: T): List[T] =
+    val zero = implicitly[Numeric[T]].zero
+    xs match {
+      case x :: xs1 if limit > zero => consume(xs1, limit - x)
+      case _ => xs
+    }
+}
+
+object math3 with
+  trait Ord[T] with
+    def (x: T) > (t: T): Boolean = ???
+    def (x: T) <= (t: T): Boolean = ???
+
+  trait Numeric[T] extends Ord[T] with
+    def (x: T) + (y: T): T = ???
+    def (x: T) - (y: T): T = ???
+    def (x: Int) numeric: T = ???
+end math3
+
+object Test3 with
+  import math3.Numeric
+  import collection.immutable.Seq
+
+  def consume[T: Numeric](xs: List[T], limit: T): List[T] = xs match
+    case x :: xs1 if limit > 0.numeric => consume(xs1, limit - x)
+    case _ => xs
+
+  def consume[T: Numeric](xs: LazyList[T], limit: T): LazyList[T] = xs match
+    case x #:: xs1 if limit > 0.numeric => consume(xs1, limit - x)
+    case _ => xs
+
+  def consume[T: Numeric](xs: Seq[T], limit: T): Seq[T] =
+    def dropCount(it: Iterator[T], start: Int, limit: T): Int =
+      if limit > 0.numeric && it.hasNext then dropCount(it, start + 1, limit - it.next)
+      else start
+    xs.drop(dropCount(xs.iterator, 0, limit))
+
+  def consume[T: Numeric](xs: Iterable[T], limit: T): Iterable[T] =
+    var sum = 0.numeric
+    xs.dropWhile { x =>
+      try sum <= limit finally sum += x
+    }
+
+  def consume2[T: Numeric](xs: Iterable[T], limit: T): Iterable[T] =
+    consume2(LazyList.from(xs), limit)
+end Test3
+