diff options
Diffstat (limited to 'test')
71 files changed, 471 insertions, 331 deletions
diff --git a/test/disabled/run/lisp.scala b/test/disabled/run/lisp.scala index 06e68f508a..73f24da757 100644 --- a/test/disabled/run/lisp.scala +++ b/test/disabled/run/lisp.scala @@ -12,11 +12,11 @@ class LispTokenizer(s: String) extends Iterator[String] { while (i < s.length() && s.charAt(i) <= ' ') i += 1 i < s.length() } - def next: String = + def next: String = if (hasNext) { val start = i if (isDelimiter(s charAt i)) i += 1 - else + else do i = i + 1 while (!isDelimiter(s charAt i)) s.substring(start, i) @@ -190,10 +190,10 @@ object LispCaseClasses extends Lisp { def extendEnv(env: Environment, ps: List[String], args: List[Data]): Environment = - Pair(ps, args) match { - case Pair(List(), List()) => + (ps, args) match { + case (List(), List()) => env - case Pair(p :: ps1, arg :: args1) => + case (p :: ps1, arg :: args1) => extendEnv(env.extend(p, arg), ps1, args1) case _ => lispError("wrong number of arguments") @@ -381,10 +381,10 @@ object LispAny extends Lisp { def extendEnv(env: Environment, ps: List[String], args: List[Data]): Environment = - Pair(ps, args) match { - case Pair(List(), List()) => + (ps, args) match { + case (List(), List()) => env - case Pair(p :: ps1, arg :: args1) => + case (p :: ps1, arg :: args1) => extendEnv(env.extend(p, arg), ps1, args1) case _ => lispError("wrong number of arguments") diff --git a/test/files/jvm/non-fatal-tests.scala b/test/files/jvm/non-fatal-tests.scala index 791b1d3100..1ff7ee516e 100644 --- a/test/files/jvm/non-fatal-tests.scala +++ b/test/files/jvm/non-fatal-tests.scala @@ -4,8 +4,7 @@ trait NonFatalTests { //NonFatals val nonFatals: Seq[Throwable] = - Seq(new StackOverflowError, - new RuntimeException, + Seq(new RuntimeException, new Exception, new Throwable, new NotImplementedError) @@ -13,6 +12,7 @@ trait NonFatalTests { //Fatals val fatals: Seq[Throwable] = Seq(new InterruptedException, + new StackOverflowError, new OutOfMemoryError, new LinkageError, new VirtualMachineError {}, diff --git a/test/files/jvm/typerep.scala b/test/files/jvm/typerep.scala index 1d6f0b7907..4f900d98d7 100644 --- a/test/files/jvm/typerep.scala +++ b/test/files/jvm/typerep.scala @@ -86,7 +86,7 @@ object testArrays { object testTuples { println(getType((3, "abc"))) - println(getType(Triple('a', 'b', "c"))) + println(getType(('a', 'b', "c"))) println(getType(((3, "abc"), (4, "xyz")))) println(getType(((Some('b'), 3), (Some('a'), 4)))) //println(getType(((Some('b'), 3), (None, 4)))) diff --git a/test/files/neg/class-of-double-targs.check b/test/files/neg/class-of-double-targs.check new file mode 100644 index 0000000000..f7e2094f97 --- /dev/null +++ b/test/files/neg/class-of-double-targs.check @@ -0,0 +1,4 @@ +class-of-double-targs.scala:2: error: expression of type Class[Int](classOf[scala.Int]) does not take type parameters. + classOf[Int][Int] + ^ +one error found diff --git a/test/files/neg/class-of-double-targs.scala b/test/files/neg/class-of-double-targs.scala new file mode 100644 index 0000000000..26a2fa8381 --- /dev/null +++ b/test/files/neg/class-of-double-targs.scala @@ -0,0 +1,3 @@ +object Test { + classOf[Int][Int] +} diff --git a/test/files/neg/patmatexhaust.scala b/test/files/neg/patmatexhaust.scala index aa7dac7d7d..f937197829 100644 --- a/test/files/neg/patmatexhaust.scala +++ b/test/files/neg/patmatexhaust.scala @@ -22,9 +22,9 @@ class TestSealedExhaustive { // compile only def ma3(x:Mult) = (x,x) match { // not exhaustive case (Kult(_), Qult()) => // Kult missing - //case Pair(Kult(_), Kult(_)) => + //case (Kult(_), Kult(_)) => case (Qult(), Kult(_)) => // Qult missing - //case Pair(Qult(), Qult()) => + //case (Qult(), Qult()) => } def ma3u(x:Mult) = ((x,x) : @unchecked) match { // not exhaustive, but not checked! diff --git a/test/files/neg/t414.scala b/test/files/neg/t414.scala index 1662b9a105..86646d13c2 100644 --- a/test/files/neg/t414.scala +++ b/test/files/neg/t414.scala @@ -1,5 +1,5 @@ case class Empty[a]() extends IntMap[a]; -case class Node[a](left: IntMap[a], keyVal: Pair[Int, a], right: IntMap[a]) extends IntMap[a]; +case class Node[a](left: IntMap[a], keyVal: Tuple2[Int, a], right: IntMap[a]) extends IntMap[a]; abstract class IntMap[a] { def lookup(key: Int): a = this match { case Empty => diff --git a/test/files/neg/t5702-neg-bad-and-wild.check b/test/files/neg/t5702-neg-bad-and-wild.check index ff9e5e5703..a52136dbf8 100644 --- a/test/files/neg/t5702-neg-bad-and-wild.check +++ b/test/files/neg/t5702-neg-bad-and-wild.check @@ -23,6 +23,6 @@ t5702-neg-bad-and-wild.scala:23: error: bad simple pattern: bad use of _* (a seq val K(ns @ _*, x) = k // bad use of _* (a sequence pattern must be the last pattern) ^ t5702-neg-bad-and-wild.scala:24: error: bad simple pattern: bad use of _* (sequence pattern not allowed) - val (b, _ * ) = Pair(5,6) // bad use of _* (sequence pattern not allowed) + val (b, _ * ) = (5,6) // bad use of _* (sequence pattern not allowed) ^ 9 errors found diff --git a/test/files/neg/t5702-neg-bad-and-wild.scala b/test/files/neg/t5702-neg-bad-and-wild.scala index 3833a002b1..aadda37da7 100644 --- a/test/files/neg/t5702-neg-bad-and-wild.scala +++ b/test/files/neg/t5702-neg-bad-and-wild.scala @@ -21,7 +21,7 @@ object Test { //gowild.scala:14: error: star patterns must correspond with varargs parameters val K(is @ _*) = k val K(ns @ _*, x) = k // bad use of _* (a sequence pattern must be the last pattern) - val (b, _ * ) = Pair(5,6) // bad use of _* (sequence pattern not allowed) + val (b, _ * ) = (5,6) // bad use of _* (sequence pattern not allowed) // no longer complains //bad-and-wild.scala:15: error: ')' expected but '}' found. } diff --git a/test/files/neg/t997.scala b/test/files/neg/t997.scala index e8d10f4317..1198738f24 100644 --- a/test/files/neg/t997.scala +++ b/test/files/neg/t997.scala @@ -1,5 +1,5 @@ // An extractor with 2 results -object Foo { def unapply(x : String) = Some(Pair(x, x)) } +object Foo { def unapply(x : String) = Some((x, x)) } object Test extends App { diff --git a/test/files/neg/wellkinded_wrongarity.check b/test/files/neg/wellkinded_wrongarity.check index 1dc38db5c1..b9f033b453 100644 --- a/test/files/neg/wellkinded_wrongarity.check +++ b/test/files/neg/wellkinded_wrongarity.check @@ -1,4 +1,4 @@ -wellkinded_wrongarity.scala:5: error: Pair takes two type parameters, expected: one -object mp extends Monad[Pair] +wellkinded_wrongarity.scala:5: error: Tuple2 takes two type parameters, expected: one +object mp extends Monad[Tuple2] ^ one error found diff --git a/test/files/neg/wellkinded_wrongarity.scala b/test/files/neg/wellkinded_wrongarity.scala index 2bb0e2ce8a..39c7601d53 100644 --- a/test/files/neg/wellkinded_wrongarity.scala +++ b/test/files/neg/wellkinded_wrongarity.scala @@ -2,4 +2,4 @@ class Monad[m[x]] -object mp extends Monad[Pair] +object mp extends Monad[Tuple2] diff --git a/test/files/pos/bounds.scala b/test/files/pos/bounds.scala index cfea4626c3..26bc84a1b9 100644 --- a/test/files/pos/bounds.scala +++ b/test/files/pos/bounds.scala @@ -1,11 +1,11 @@ trait Map[A, +C] { - def ++ [B1 >: C] (kvs: Iterable[Pair[A, B1]]): Map[A, B1] = this - def ++ [B1 >: C] (kvs: Iterator[Pair[A, B1]]): Map[A, B1] = this + def ++ [B1 >: C] (kvs: Iterable[Tuple2[A, B1]]): Map[A, B1] = this + def ++ [B1 >: C] (kvs: Iterator[Tuple2[A, B1]]): Map[A, B1] = this } class ListMap[A, +B] extends Map[A, B] {} object ListMap { def empty[X, Y] = new ListMap[X, Y] - def apply[A1, B2](elems: Pair[A1, B2]*): Map[A1, B2] = empty[A1,B2].++(elems.iterator) + def apply[A1, B2](elems: Tuple2[A1, B2]*): Map[A1, B2] = empty[A1,B2].++(elems.iterator) } diff --git a/test/files/pos/macro-implicit-invalidate-on-error.check b/test/files/pos/macro-implicit-invalidate-on-error.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/pos/macro-implicit-invalidate-on-error.check diff --git a/test/files/pos/macro-implicit-invalidate-on-error.scala b/test/files/pos/macro-implicit-invalidate-on-error.scala new file mode 100644 index 0000000000..22cd2d34b4 --- /dev/null +++ b/test/files/pos/macro-implicit-invalidate-on-error.scala @@ -0,0 +1,28 @@ +package scala.reflect +package api + +import scala.language.experimental.macros +import scala.reflect.macros.Context + +trait Liftable[T] { + def apply(universe: api.Universe, value: T): universe.Tree +} + +object Liftable { + implicit def liftCaseClass[T <: Product]: Liftable[T] = macro liftCaseClassImpl[T] + + def liftCaseClassImpl[T: c.WeakTypeTag](c: Context): c.Expr[Liftable[T]] = { + import c.universe._ + val tpe = weakTypeOf[T] + if (!tpe.typeSymbol.asClass.isCaseClass) c.abort(c.enclosingPosition, "denied") + val p = List(q"Literal(Constant(1))") + c.Expr[Liftable[T]] { q""" + new scala.reflect.api.Liftable[$tpe] { + def apply(universe: scala.reflect.api.Universe, value: $tpe): universe.Tree = { + import universe._ + Apply(Select(Ident(TermName("C")), TermName("apply")), List(..$p)) + } + } + """ } + } +} diff --git a/test/files/pos/patmat.scala b/test/files/pos/patmat.scala index 4e652b146e..51b879abf2 100644 --- a/test/files/pos/patmat.scala +++ b/test/files/pos/patmat.scala @@ -3,8 +3,8 @@ object ZipFun { //just compilation - def zipFun[a, b](xs: List[a], ys: List[b]): List[Pair[a, b]] = (Pair(xs, ys): @unchecked) match { - // !!! case Pair(List(), _), Pair(_, List()) => List() + def zipFun[a, b](xs: List[a], ys: List[b]): List[Tuple2[a, b]] = ((xs, ys): @unchecked) match { + // !!! case (List(), _), (_, List()) => List() case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1) } } diff --git a/test/files/pos/spec-doubledef-new.scala b/test/files/pos/spec-doubledef-new.scala index ad9c6399a5..589ceb33b2 100644 --- a/test/files/pos/spec-doubledef-new.scala +++ b/test/files/pos/spec-doubledef-new.scala @@ -19,12 +19,12 @@ abstract class B[T, @specialized(scala.Int) U : TypeTag, @specialized(scala.Int) val u: U val v: V - def f(t: T, v2: V): Pair[U, V] = { + def f(t: T, v2: V): Tuple2[U, V] = { val m: Array[U] = null if (m.isEmpty) { - Pair(u, v) + (u, v) } else { - Pair(u, v2) + (u, v2) } } }
\ No newline at end of file diff --git a/test/files/pos/spec-doubledef-old.scala b/test/files/pos/spec-doubledef-old.scala index 86b0d857d3..bde259e4fa 100644 --- a/test/files/pos/spec-doubledef-old.scala +++ b/test/files/pos/spec-doubledef-old.scala @@ -17,12 +17,12 @@ abstract class B[T, @specialized(scala.Int) U : Manifest, @specialized(scala.Int val u: U val v: V - def f(t: T, v2: V): Pair[U, V] = { + def f(t: T, v2: V): Tuple2[U, V] = { val m: Array[U] = null if (m.isEmpty) { - Pair(u, v) + (u, v) } else { - Pair(u, v2) + (u, v2) } } } diff --git a/test/files/pos/t0064.scala b/test/files/pos/t0064.scala index c2ce4bf6d0..1eeca8dcad 100644 --- a/test/files/pos/t0064.scala +++ b/test/files/pos/t0064.scala @@ -1,6 +1,6 @@ object B { def main(Args:Array[String]) = { - val Pair(_,x) = Pair(1,2); + val (_,x) = (1,2); x + 1; } } diff --git a/test/files/pos/t247.scala b/test/files/pos/t247.scala index e976404e61..fdcafeb2c6 100644 --- a/test/files/pos/t247.scala +++ b/test/files/pos/t247.scala @@ -16,11 +16,11 @@ class Tree[KEY,Entry](order:Order[KEY]) { def size =0; } -class TreeMap[KEY,VALUE](_factory:TreeMapFactory[KEY]) extends Tree[KEY,Pair[KEY,VALUE]](_factory.order) with scala.collection.DefaultMap[KEY, VALUE] with Map[KEY, VALUE] { +class TreeMap[KEY,VALUE](_factory:TreeMapFactory[KEY]) extends Tree[KEY,Tuple2[KEY,VALUE]](_factory.order) with scala.collection.DefaultMap[KEY, VALUE] with Map[KEY, VALUE] { val factory = _factory val order = _factory.order; def this(newOrder:Order[KEY]) = this(new TreeMapFactory[KEY](newOrder)); def get(key:KEY) = null; - def iterator:Iterator[Pair[KEY,VALUE]] = null; + def iterator:Iterator[Tuple2[KEY,VALUE]] = null; override def size = super[Tree].size } diff --git a/test/files/pos/t443.scala b/test/files/pos/t443.scala index 5b5e3ea828..cdaefe9ecd 100644 --- a/test/files/pos/t443.scala +++ b/test/files/pos/t443.scala @@ -1,10 +1,10 @@ object Test { - def lookup(): Option[Pair[String, String]] = - ((null: Option[Pair[String, String]]) : @unchecked) match { - case Some(Pair(_, _)) => + def lookup(): Option[Tuple2[String, String]] = + ((null: Option[Tuple2[String, String]]) : @unchecked) match { + case Some((_, _)) => if (true) - Some(Pair(null, null)) + Some((null, null)) else lookup() match { case Some(_) => Some(null) diff --git a/test/files/pos/t4579.scala b/test/files/pos/t4579.scala index 8951ec011f..cd1553f02a 100644 --- a/test/files/pos/t4579.scala +++ b/test/files/pos/t4579.scala @@ -190,10 +190,10 @@ object LispCaseClasses extends Lisp { def extendEnv(env: Environment, ps: List[String], args: List[Data]): Environment = - Pair(ps, args) match { - case Pair(List(), List()) => + (ps, args) match { + case (List(), List()) => env - case Pair(p :: ps1, arg :: args1) => + case (p :: ps1, arg :: args1) => extendEnv(env.extend(p, arg), ps1, args1) case _ => lispError("wrong number of arguments") @@ -381,10 +381,10 @@ object LispAny extends Lisp { def extendEnv(env: Environment, ps: List[String], args: List[Data]): Environment = - Pair(ps, args) match { - case Pair(List(), List()) => + (ps, args) match { + case (List(), List()) => env - case Pair(p :: ps1, arg :: args1) => + case (p :: ps1, arg :: args1) => extendEnv(env.extend(p, arg), ps1, args1) case _ => lispError("wrong number of arguments") diff --git a/test/files/pos/t5120.scala b/test/files/pos/t5120.scala index 6731af14e4..86d4470bd5 100644 --- a/test/files/pos/t5120.scala +++ b/test/files/pos/t5120.scala @@ -5,9 +5,9 @@ class Test { class ScopedKey[T] class Value[T] - class Compiled[T](val settings: Seq[Pair[T]]) + class Compiled[T](val settings: Seq[Tuple2[T]]) - case class Pair[T](k: ScopedKey[T], v: ScopedKey[T]) + case class Tuple2[T](k: ScopedKey[T], v: ScopedKey[T]) def transform[T](x: T) = x diff --git a/test/files/pos/t7983.scala b/test/files/pos/t7983.scala new file mode 100644 index 0000000000..a583e538c5 --- /dev/null +++ b/test/files/pos/t7983.scala @@ -0,0 +1,31 @@ +package foo.bar.baz // the package nesting level material to this bug + +class DivergenceTest { + + trait ColumnBase[T] + + trait ShapeLevel + trait Flat extends ShapeLevel + trait Lower extends Flat + + class Shape2[Level <: ShapeLevel, -M, U] + + implicit final def columnBaseShape[Level >: Flat <: ShapeLevel, T, C <: ColumnBase[_]] + (implicit ev: C <:< ColumnBase[T] + ): Shape2[Level, C, T] = ??? + + implicit final def intShape[Level <: ShapeLevel, T]: Shape2[Level, Int, Int] = ??? + implicit final def tuple2Shape[Level <: ShapeLevel, M1,M2, U1,U2] + (implicit u1: Shape2[_ <: Level, M1, U1], + u2: Shape2[_ <: Level, M2, U2] + ): Shape2[Level, (M1,M2), (U1,U2)] = ??? + + def foo { + class Coffees extends ColumnBase[Int] + + def map1[F, T](f: F)(implicit shape: Shape2[_ <: Flat, F, T]) = ??? + + map1(((1, null: Coffees), 1)) + map1(((null: Coffees, 1), 1)) // fails with implicit divergence error in 2.11.0-M6, works under 2.10.3 + } +} diff --git a/test/files/pos/t7987/Macro_1.scala b/test/files/pos/t7987/Macro_1.scala new file mode 100644 index 0000000000..81f717b9c4 --- /dev/null +++ b/test/files/pos/t7987/Macro_1.scala @@ -0,0 +1,6 @@ +import scala.language.experimental._ + +object Macro { + def apply[A](a: A): A = macro impl[A] + def impl[A](c: reflect.macros.Context)(a: c.Expr[A]): c.Expr[A] = a +} diff --git a/test/files/pos/t7987/Test_2.scala b/test/files/pos/t7987/Test_2.scala new file mode 100644 index 0000000000..5896fdb517 --- /dev/null +++ b/test/files/pos/t7987/Test_2.scala @@ -0,0 +1,12 @@ +class C[T] { + def foo = 0 +} + +object Test { + implicit def AnyToC[T](a: Any): C[T] = new C[T] + // was: "macro not expanded" + Macro { + "".foo + () + } +} diff --git a/test/files/pos/tcpoly_bounds1.scala b/test/files/pos/tcpoly_bounds1.scala index 5874cc664d..63263cb152 100644 --- a/test/files/pos/tcpoly_bounds1.scala +++ b/test/files/pos/tcpoly_bounds1.scala @@ -1,7 +1,7 @@ -class Foo[t[x]<: Pair[Int, x]] +class Foo[t[x]<: Tuple2[Int, x]] // -class MyPair[z](a: Int, b: z) extends Pair[Int, z](a,b) +class MyPair[z](a: Int, b: z) extends Tuple2[Int, z](a,b) object foo extends Foo[MyPair] diff --git a/test/files/pos/typealiases.scala b/test/files/pos/typealiases.scala index d03b521f77..93d1dce4dc 100644 --- a/test/files/pos/typealiases.scala +++ b/test/files/pos/typealiases.scala @@ -14,7 +14,7 @@ trait Test[T] { object main extends Test[Int] { val pair1 = (1,1) - implicit def topair(x: Int): Pair[Int, Int] = (x,x) + implicit def topair(x: Int): Tuple2[Int, Int] = (x,x) val pair2: MyPair[Int] = 1 val x: Short = 1 } diff --git a/test/files/pos/unapplyNeedsMemberType.scala b/test/files/pos/unapplyNeedsMemberType.scala index b423257e04..3a96e189af 100644 --- a/test/files/pos/unapplyNeedsMemberType.scala +++ b/test/files/pos/unapplyNeedsMemberType.scala @@ -19,7 +19,7 @@ class Join[a] extends Gunk[a] { def append(s1: Seq, s2: Seq): Seq = s1 // mock implementation def unapply_Cons(s: Any) = s match { - case App(Cons(x, xs), ys) => Some(Pair(x, append(xs, ys))) + case App(Cons(x, xs), ys) => Some((x, append(xs, ys))) case _ => null } } diff --git a/test/files/pos/valdefs.scala b/test/files/pos/valdefs.scala index 85ffa132b7..c8f78cd2bf 100644 --- a/test/files/pos/valdefs.scala +++ b/test/files/pos/valdefs.scala @@ -11,6 +11,6 @@ object test { } abstract class Sub2() extends Base() { - override val Pair(x, y) = Pair("abc", 2.0); + override val (x, y) = ("abc", 2.0); } } diff --git a/test/files/positions/ExcludedPrefix1.scala b/test/files/positions/ExcludedPrefix1.scala index f3562c37f0..b3182eae78 100644 --- a/test/files/positions/ExcludedPrefix1.scala +++ b/test/files/positions/ExcludedPrefix1.scala @@ -35,7 +35,7 @@ object ExcludedPrefix1 { (i, j) = (0, 0) - val Pair( + val ( k, l) = (0, 0) } diff --git a/test/files/positions/Overlap4.scala b/test/files/positions/Overlap4.scala index 0049293954..f54837295b 100644 --- a/test/files/positions/Overlap4.scala +++ b/test/files/positions/Overlap4.scala @@ -1,3 +1,3 @@ object Overlap4 { - val Pair(a, b) = (0, 0) + val (a, b) = (0, 0) } diff --git a/test/files/positions/Scaladoc7.scala b/test/files/positions/Scaladoc7.scala index 6175222e3f..0198d4d6ac 100644 --- a/test/files/positions/Scaladoc7.scala +++ b/test/files/positions/Scaladoc7.scala @@ -2,5 +2,5 @@ object Scaladoc7 { /** * Foo */ - val Pair(i, j) = (1, 2) + val (i, j) = (1, 2) } diff --git a/test/files/presentation/callcc-interpreter.check b/test/files/presentation/callcc-interpreter.check index f031c52c86..1f868097ca 100644 --- a/test/files/presentation/callcc-interpreter.check +++ b/test/files/presentation/callcc-interpreter.check @@ -1,8 +1,8 @@ reload: CallccInterpreter.scala -askTypeCompletion at CallccInterpreter.scala(51,38) +askTypeCompletion at CallccInterpreter.scala(51,34) ================================================================================ -[response] askTypeCompletion at (51,38) +[response] askTypeCompletion at (51,34) retrieved 59 members abstract trait Term extends AnyRef abstract trait Value extends AnyRef @@ -83,8 +83,8 @@ def showM(m: callccInterpreter.M[callccInterpreter.Value]): String = m.in.apply( askType at CallccInterpreter.scala(50,30) ================================================================================ [response] askTypeAt (50,30) -def add(a: callccInterpreter.Value, b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value] = scala.this.Predef.Pair.apply[callccInterpreter.Value, callccInterpreter.Value](a, b) match { - case scala.this.Predef.Pair.unapply[callccInterpreter.Value, callccInterpreter.Value](<unapply-selector>) <unapply> ((n: Int)callccInterpreter.Num((m @ _)), (n: Int)callccInterpreter.Num((n @ _))) => this.unitM[callccInterpreter.Num](callccInterpreter.this.Num.apply(m.+(n))) +def add(a: callccInterpreter.Value, b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value] = scala.Tuple2.apply[callccInterpreter.Value, callccInterpreter.Value](a, b) match { + case (_1: callccInterpreter.Value, _2: callccInterpreter.Value)(callccInterpreter.Value, callccInterpreter.Value)((n: Int)callccInterpreter.Num((m @ _)), (n: Int)callccInterpreter.Num((n @ _))) => this.unitM[callccInterpreter.Num](callccInterpreter.this.Num.apply(m.+(n))) case _ => callccInterpreter.this.unitM[callccInterpreter.Wrong.type](callccInterpreter.this.Wrong) } ================================================================================ diff --git a/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala b/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala index ce3b996b96..d498fe0b17 100644 --- a/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala +++ b/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala @@ -40,15 +40,15 @@ object callccInterpreter { override def toString() = "<function>" } - type Environment = List[Pair[Name, Value]] + type Environment = List[Tuple2[Name, Value]] def lookup(x: Name, e: Environment): M[Value] = e match { case List() => unitM(Wrong) - case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) + case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) } - def add(a: Value, b: Value) /*?*/ = Pair(a, b) match { - case Pair(Num(m), Num(n)) => this./*!*/unitM(Num(m + n)) + def add(a: Value, b: Value) /*?*/ = (a, b) match { + case (Num(m), Num(n)) => this./*!*/unitM(Num(m + n)) case _ => unitM(Wrong) } @@ -60,16 +60,20 @@ object callccInterpreter { def interp(t: Term, e: Environment): M[Value] = t match { case Var(x) => lookup(x, e) case Con(n) => unitM(Num(n)) - case Add(l, r) => for (val a <- interp(l, e); - val b <- interp(r, e); - val c <- add(a, b)) - yield c - case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e))) - case App(f, t) => for (val a <- interp(f, e); - val b <- interp(t, e); - val c <- apply(a, b)) - yield c - case Ccc(x, t) => callCC(k => interp(t, Pair(x, Fun(k)) :: e)) + case Add(l, r) => + for { + a <- interp(l, e) + b <- interp(r, e) + c <- add(a, b) + } yield c + case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e))) + case App(f, t) => + for { + a <- interp(f, e) + b <- interp(t, e) + c <- apply(a, b) + } yield c + case Ccc(x, t) => callCC(k => interp(t, (x, Fun(k)) :: e)) } def test(t: Term): String = showM(interp(t, List())) diff --git a/test/files/run/Course-2002-05.scala b/test/files/run/Course-2002-05.scala index e6764b92c8..80317bc757 100644 --- a/test/files/run/Course-2002-05.scala +++ b/test/files/run/Course-2002-05.scala @@ -3,15 +3,15 @@ //############################################################################ object M0 { - def partition[a](xs: List[a], pred: a => Boolean): Pair[List[a], List[a]] = { + def partition[a](xs: List[a], pred: a => Boolean): Tuple2[List[a], List[a]] = { if (xs.isEmpty) - Pair(List(),List()) + (List(),List()) else { val tailPartition = partition(xs.tail, pred); if (pred(xs.head)) - Pair(xs.head :: tailPartition._1, tailPartition._2) + (xs.head :: tailPartition._1, tailPartition._2) else - Pair(tailPartition._1, xs.head :: tailPartition._2) + (tailPartition._1, xs.head :: tailPartition._2) } } @@ -49,9 +49,9 @@ object M0 { //############################################################################ object M1 { - def partition[a](xs: List[a], pred: a => Boolean): Pair[List[a], List[a]] = { - xs.foldRight[Pair[List[a], List[a]]](Pair(List(), List())) { - (x, p) => if (pred (x)) Pair(x :: p._1, p._2) else Pair(p._1, x :: p._2) + def partition[a](xs: List[a], pred: a => Boolean): Tuple2[List[a], List[a]] = { + xs.foldRight[Tuple2[List[a], List[a]]]((List(), List())) { + (x, p) => if (pred (x)) (x :: p._1, p._2) else (p._1, x :: p._2) } } @@ -136,7 +136,7 @@ object M3 { def adjoinRow(placement: Placement): List[Placement] = range(1, n) .filter (column => isSafe(column, placement)) - .map (column => Pair(row, column) :: placement); + .map (column => (row, column) :: placement); placeQueens(row - 1) flatMap adjoinRow } diff --git a/test/files/run/Course-2002-06.scala b/test/files/run/Course-2002-06.scala index e4fb86a966..908a934041 100644 --- a/test/files/run/Course-2002-06.scala +++ b/test/files/run/Course-2002-06.scala @@ -55,7 +55,7 @@ abstract class Graphics(_width: Double, _height: Double) { } /** Draw a list of segments on the picture.*/ - def drawSegments(frm: Frame)(segments: List[Pair[Vector, Vector]]): Unit = + def drawSegments(frm: Frame)(segments: List[Tuple2[Vector, Vector]]): Unit = if (segments.isEmpty) () else { drawSegment(frm)(segments.head._1, segments.head._2); diff --git a/test/files/run/Course-2002-07.scala b/test/files/run/Course-2002-07.scala index 055ff74d81..2d9457653f 100644 --- a/test/files/run/Course-2002-07.scala +++ b/test/files/run/Course-2002-07.scala @@ -181,10 +181,10 @@ object M4 { object M5 { - def zipFun[a,b](xs:List[a], ys:List[b]):List[Pair[a,b]] = Pair(xs,ys) match { - case Pair(List(), _) => List() - case Pair(_, List()) => List() - case Pair(x :: xs1, y :: ys1) => Pair(x, y) :: zipFun(xs1, ys1) + def zipFun[a,b](xs:List[a], ys:List[b]):List[Tuple2[a,b]] = (xs,ys) match { + case (List(), _) => List() + case (_, List()) => List() + case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1) } def test_zipFun[a,b](xs: List[a], ys: List[b]) = { @@ -216,9 +216,9 @@ object M5 { object M6 { - def zipFun[a,b](xs:List[a], ys:List[b]):List[Pair[a,b]] = (Pair(xs,ys): @unchecked) match { - // !!! case Pair(List(), _), Pair(_, List()) => List() - case Pair(x :: xs1, y :: ys1) => Pair(x, y) :: zipFun(xs1, ys1) + def zipFun[a,b](xs:List[a], ys:List[b]):List[Tuple2[a,b]] = ((xs,ys): @unchecked) match { + // !!! case (List(), _), (_, List()) => List() + case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1) } def test_zipFun[a,b](xs: List[a], ys: List[b]) = { @@ -374,9 +374,9 @@ object M9 { object MA { - def lookup[k,v](xs: List[Pair[k,v]], k: k): v = xs match { + def lookup[k,v](xs: List[Tuple2[k,v]], k: k): v = xs match { case List() => sys.error("no value for " + k) - case Pair(k1,v1) :: xs1 => if (k1 == k) v1 else lookup(xs1, k) + case (k1,v1) :: xs1 => if (k1 == k) v1 else lookup(xs1, k) } trait Expr { @@ -437,8 +437,8 @@ object MA { val g1 = g0 derive x; Console.println("g (x) = " + g0); Console.println("g'(x) = " + g1); - Console.println("g (3) = " + evalvars(List(Pair("x",3)))(g0)); - Console.println("g'(3) = " + evalvars(List(Pair("x",3)))(g1)); + Console.println("g (3) = " + evalvars(List(("x",3)))(g0)); + Console.println("g'(3) = " + evalvars(List(("x",3)))(g1)); Console.println; } @@ -453,26 +453,26 @@ object Utils { if (y == 1) x else if (y % 2 == 0) power0(x*x,y/2) else x*power0(x, y-1); def power(x: Int, y: Int): Int = (x,y) match { - case Pair(0,0) => sys.error("power(0,0)") - case Pair(0,_) => 0 - case Pair(1,_) => 1 - case Pair(_,0) => 1 - case Pair(_,1) => x - case Pair(_,2) => x*x - case Pair(_,_) => if (y < 0) 1/power0(x,y) else power0(x,y) + case (0,0) => sys.error("power(0,0)") + case (0,_) => 0 + case (1,_) => 1 + case (_,0) => 1 + case (_,1) => x + case (_,2) => x*x + case (_,_) => if (y < 0) 1/power0(x,y) else power0(x,y) } def lookup(entries: List[(String,Int)], key: String): Int = entries match { case List() => sys.error("no value for " + key) - case Pair(k,v) :: _ if (k == key) => v + case (k,v) :: _ if (k == key) => v case _ :: rest => lookup(rest, key) } def compare(xs: List[String], ys: List[String]): Int = (xs, ys) match { - case Pair(List(), List()) => 0 - case Pair(List(), _ ) => -1 - case Pair(_ , List()) => +1 - case Pair(x::xs , y::ys ) => { + case (List(), List()) => 0 + case (List(), _ ) => -1 + case (_ , List()) => +1 + case (x::xs , y::ys ) => { val diff = x.compareTo(y); if (diff != 0) diff else compare(xs,ys) } @@ -508,18 +508,18 @@ object MB { private def +< (that: Expr): Boolean = (this +<? that) < 0; private def +<= (that: Expr): Boolean = (this +<? that) <= 0; - private def +<? (that: Expr): Int = Pair(this,that) match { - case Pair(Add(_,_), _ ) => 0 - case Pair(_ , Add(_,_)) => 0 - case Pair(_ , _ ) => compare(this.vars,that.vars) + private def +<? (that: Expr): Int = (this,that) match { + case (Add(_,_), _ ) => 0 + case (_ , Add(_,_)) => 0 + case (_ , _ ) => compare(this.vars,that.vars) } - def + (that: Expr): Expr = if (that +<= this) Pair(this,that) match { - case Pair(_ , Lit(0) ) => this - case Pair(Lit(l) , Lit(r) ) => Lit(l + r) - case Pair(_ , Add(rl,rr)) => (this + rl) + rr - case Pair(Add(ll,lr), _ ) if (lr +<= that) => ll + (that + lr) - case Pair(_ , _ ) => { + def + (that: Expr): Expr = if (that +<= this) (this,that) match { + case (_ , Lit(0) ) => this + case (Lit(l) , Lit(r) ) => Lit(l + r) + case (_ , Add(rl,rr)) => (this + rl) + rr + case (Add(ll,lr), _ ) if (lr +<= that) => ll + (that + lr) + case (_ , _ ) => { val l = this.term; val r = that.term; if (l equ r) Lit(this.count + that.count) * r else Add(this, that) @@ -528,41 +528,41 @@ object MB { private def *< (that: Expr): Boolean = (this *<? that) < 0; private def *<= (that: Expr): Boolean = (this *<? that) <= 0; - private def *<? (that: Expr): Int = Pair(this,that) match { - case Pair(Mul(_,_), _ ) => 0 - case Pair(_ , Mul(_,_)) => 0 - case Pair(Add(_,_), Add(_,_)) => 0 - case Pair(Add(_,_), _ ) => -1 - case Pair(_ , Add(_,_)) => +1 - case Pair(Lit(_) , Lit(_) ) => 0 - case Pair(Lit(_) , _ ) => -1 - case Pair(_ , Lit(_) ) => +1 - case Pair(Var(l) , Var(r) ) => l.compareTo(r) - case Pair(Var(_) , Pow(r,_)) => if (this *<= r) -1 else +1 - case Pair(Pow(l,_), Var(_) ) => if (l *< that) -1 else +1 - case Pair(Pow(l,_), Pow(r,_)) => l *<? r + private def *<? (that: Expr): Int = (this,that) match { + case (Mul(_,_), _ ) => 0 + case (_ , Mul(_,_)) => 0 + case (Add(_,_), Add(_,_)) => 0 + case (Add(_,_), _ ) => -1 + case (_ , Add(_,_)) => +1 + case (Lit(_) , Lit(_) ) => 0 + case (Lit(_) , _ ) => -1 + case (_ , Lit(_) ) => +1 + case (Var(l) , Var(r) ) => l.compareTo(r) + case (Var(_) , Pow(r,_)) => if (this *<= r) -1 else +1 + case (Pow(l,_), Var(_) ) => if (l *< that) -1 else +1 + case (Pow(l,_), Pow(r,_)) => l *<? r } - def * (that: Expr): Expr = if (this *<= that) Pair(this,that) match { - case Pair(Lit(0) , _ ) => this - case Pair(Lit(1) , _ ) => that - case Pair(Mul(ll,lr), r ) => ll * (lr * r) - case Pair(Add(ll,lr), r ) => ll * r + lr * r - case Pair(Lit(l) , Lit(r) ) => Lit(l * r) - case Pair(Var(_) , Var(_) ) if (this equ that) => Pow(this,2) - case Pair(Var(_) , Pow(r,n) ) if (this equ r) => Pow(this,n + 1) - case Pair(Pow(ll,lr), Pow(rl,rr)) if (ll equ rl) => Pow(ll,lr + rr) - case Pair(l , Mul(rl,rr)) if (rl *<= l) => (rl * l) * rr - case Pair(_ , _ ) => Mul(this,that) + def * (that: Expr): Expr = if (this *<= that) (this,that) match { + case (Lit(0) , _ ) => this + case (Lit(1) , _ ) => that + case (Mul(ll,lr), r ) => ll * (lr * r) + case (Add(ll,lr), r ) => ll * r + lr * r + case (Lit(l) , Lit(r) ) => Lit(l * r) + case (Var(_) , Var(_) ) if (this equ that) => Pow(this,2) + case (Var(_) , Pow(r,n) ) if (this equ r) => Pow(this,n + 1) + case (Pow(ll,lr), Pow(rl,rr)) if (ll equ rl) => Pow(ll,lr + rr) + case (l , Mul(rl,rr)) if (rl *<= l) => (rl * l) * rr + case (_ , _ ) => Mul(this,that) } else that * this; def ^ (that: Int): Expr = (this,that) match { - case Pair(_ ,1) => this - case Pair(Lit(i) ,n) => Lit(power(i,n)) - case Pair(Var(_) ,n) => Pow(this,n) - case Pair(Add(_,_),n) => this * (this ^ (n - 1)) - case Pair(Mul(l,r),n) => (l ^ n) * (r ^ n) - case Pair(Pow(e,m),n) => Pow(e,m + n) + case (_ ,1) => this + case (Lit(i) ,n) => Lit(power(i,n)) + case (Var(_) ,n) => Pow(this,n) + case (Add(_,_),n) => this * (this ^ (n - 1)) + case (Mul(l,r),n) => (l ^ n) * (r ^ n) + case (Pow(e,m),n) => Pow(e,m + n) } def derive(v: Var): Expr = this match { @@ -581,12 +581,12 @@ object MB { case Pow(l, r) => power(l.evaluate(vars), r) } - def equ(that: Expr): Boolean = Pair(this,that) match { - case Pair(Lit(l) ,Lit(r)) => l == r - case Pair(Var(l) ,Var(r)) => l == r - case Pair(Add(ll,lr),Add(rl,rr)) => (ll equ rl) && (lr equ rr) - case Pair(Mul(ll,lr),Mul(rl,rr)) => (ll equ rl) && (lr equ rr) - case Pair(Pow(ll,lr),Pow(rl,rr)) => (ll equ rl) && (lr == rr) + def equ(that: Expr): Boolean = (this,that) match { + case (Lit(l) ,Lit(r)) => l == r + case (Var(l) ,Var(r)) => l == r + case (Add(ll,lr),Add(rl,rr)) => (ll equ rl) && (lr equ rr) + case (Mul(ll,lr),Mul(rl,rr)) => (ll equ rl) && (lr equ rr) + case (Pow(ll,lr),Pow(rl,rr)) => (ll equ rl) && (lr == rr) case _ => false } @@ -667,7 +667,7 @@ object MB { Console.println; def check(n: String, f: Expr, x: Int, e: Int) { - val a: Int = f.evaluate(List(Pair("x",x))); + val a: Int = f.evaluate(List(("x",x))); val s: String = if (a == e) "ok" else "KO(" + e + ")"; Console.println(n + "(" + x + ") = " + a + " " + s); } diff --git a/test/files/run/Course-2002-08.scala b/test/files/run/Course-2002-08.scala index 38b8363661..5e21edaba3 100644 --- a/test/files/run/Course-2002-08.scala +++ b/test/files/run/Course-2002-08.scala @@ -163,7 +163,7 @@ object M5 { } abstract class Simulation() { - private type Agenda = List[Pair[Int, Action]]; + private type Agenda = List[Tuple2[Int, Action]]; private var agenda: Agenda = List(); private var curtime = 0; def currentTime: Int = curtime; @@ -171,17 +171,17 @@ object M5 { def afterDelay(delay: Int)(action: Action): Unit = { def insert(ag: Agenda, time: Int): Agenda = ag match { case List() => - List(Pair(time, action)) - case Pair(t, act) :: ag1 => - if (time < t) Pair(time, action) :: ag - else Pair(t, act) :: insert(ag1, time) + List((time, action)) + case (t, act) :: ag1 => + if (time < t) (time, action) :: ag + else (t, act) :: insert(ag1, time) } agenda = insert(agenda, curtime + delay) } private def next: Unit = agenda match { case List() => () - case Pair(time, action) :: ag1 => { + case (time, action) :: ag1 => { agenda = ag1; curtime = time; action(); @@ -413,7 +413,7 @@ object M5 { class Simulator() { type Action = () => Unit; - type Agenda = List[Pair[Int, Action]]; + type Agenda = List[Tuple2[Int, Action]]; private var agenda: Agenda = List(); private var curtime = 0; @@ -421,17 +421,17 @@ class Simulator() { def afterDelay(delay: Int)(action: Action) = { def insert(ag: Agenda, time: Int): Agenda = ag match { case List() => - List(Pair(time, action)) - case Pair(t, act) :: ag1 => - if (time < t) Pair(time, action) :: ag - else Pair(t, act) :: insert(ag1, time) + List((time, action)) + case (t, act) :: ag1 => + if (time < t) (time, action) :: ag + else (t, act) :: insert(ag1, time) } agenda = insert(agenda, curtime + delay) } def next: Unit = agenda match { case List() => () - case Pair(time, action) :: rest => { + case (time, action) :: rest => { agenda = rest; curtime = time; action(); @@ -567,8 +567,8 @@ class Main() extends CircuitSimulator() { demux(in, ctrl.reverse, out.reverse); probe("in", in); - for (Pair(x,c) <- range(0,n) zip ctrl) { probe("ctrl" + x, c) } - for (Pair(x,o) <- range(0,outNum) zip out) { probe("out" + x, o) } + for ((x,c) <- range(0,n) zip ctrl) { probe("ctrl" + x, c) } + for ((x,o) <- range(0,outNum) zip out) { probe("out" + x, o) } in.setSignal(true); run; diff --git a/test/files/run/Course-2002-09.scala b/test/files/run/Course-2002-09.scala index 87f91111d8..704f2ec0aa 100644 --- a/test/files/run/Course-2002-09.scala +++ b/test/files/run/Course-2002-09.scala @@ -13,11 +13,11 @@ object NoConstraint extends Constraint { } class Adder(a1: Quantity,a2: Quantity,sum: Quantity) extends Constraint { - def newValue = Triple(a1.getValue, a2.getValue, sum.getValue) match { - case Triple(Some(x1), Some(x2), _ ) => sum.setValue(x1 + x2, this) - case Triple(Some(x1), _ , Some(r)) => a2.setValue(r - x1, this) - case Triple(_ , Some(x2), Some(r)) => a1.setValue(r - x2, this) - case _ => + def newValue = (a1.getValue, a2.getValue, sum.getValue) match { + case (Some(x1), Some(x2), _ ) => sum.setValue(x1 + x2, this) + case (Some(x1), _ , Some(r)) => a2.setValue(r - x1, this) + case (_ , Some(x2), Some(r)) => a1.setValue(r - x2, this) + case _ => } def dropValue: Unit = { a1.forgetValue(this); a2.forgetValue(this); sum.forgetValue(this); @@ -29,13 +29,13 @@ class Adder(a1: Quantity,a2: Quantity,sum: Quantity) extends Constraint { class Multiplier(m1: Quantity, m2: Quantity, prod: Quantity) extends Constraint { - def newValue = Triple(m1.getValue, m2.getValue, prod.getValue) match { - case Triple(Some(0d), _ , _ ) => prod.setValue(0, this); - case Triple(_ , Some(0d), _ ) => prod.setValue(0, this); - case Triple(Some(x1), Some(x2), _ ) => prod.setValue(x1 * x2, this) - case Triple(Some(x1), _ , Some(r)) => m2.setValue(r / x1, this) - case Triple(_, Some(x2), Some(r)) => m1.setValue(r / x2, this) - case _ => + def newValue = (m1.getValue, m2.getValue, prod.getValue) match { + case (Some(0d), _ , _ ) => prod.setValue(0, this); + case (_ , Some(0d), _ ) => prod.setValue(0, this); + case (Some(x1), Some(x2), _ ) => prod.setValue(x1 * x2, this) + case (Some(x1), _ , Some(r)) => m2.setValue(r / x1, this) + case (_, Some(x2), Some(r)) => m1.setValue(r / x2, this) + case _ => } def dropValue: Unit = { m1.forgetValue(this); m2.forgetValue(this); prod.forgetValue(this); @@ -46,11 +46,11 @@ class Multiplier(m1: Quantity, m2: Quantity, prod: Quantity) } class Squarer(square: Quantity, root: Quantity) extends Constraint { - def newValue: Unit = Pair(square.getValue, root.getValue) match { - case Pair(Some(x), _ )if (x < 0) => sys.error("Square of negative number") - case Pair(Some(x), _ ) => root.setValue(Math.sqrt(x), this) - case Pair(_ , Some(x)) => square.setValue(x*x, this) - case _ => + def newValue: Unit = (square.getValue, root.getValue) match { + case (Some(x), _ )if (x < 0) => sys.error("Square of negative number") + case (Some(x), _ ) => root.setValue(Math.sqrt(x), this) + case (_ , Some(x)) => square.setValue(x*x, this) + case _ => } def dropValue: Unit = { square.forgetValue(this); root.forgetValue(this); @@ -60,9 +60,9 @@ class Squarer(square: Quantity, root: Quantity) extends Constraint { } class Eq(a: Quantity, b: Quantity) extends Constraint { - def newValue = (Pair(a.getValue, b.getValue): @unchecked) match { - case Pair(Some(x), _ ) => b.setValue(x, this); - case Pair(_ , Some(y)) => a.setValue(y, this); + def newValue = ((a.getValue, b.getValue): @unchecked) match { + case (Some(x), _ ) => b.setValue(x, this); + case (_ , Some(y)) => a.setValue(y, this); } def dropValue { a.forgetValue(this); b.forgetValue(this); diff --git a/test/files/run/Course-2002-13.scala b/test/files/run/Course-2002-13.scala index 4bd3614fb0..a596a33873 100644 --- a/test/files/run/Course-2002-13.scala +++ b/test/files/run/Course-2002-13.scala @@ -74,18 +74,18 @@ object Terms { val NoTerm = Con("<none>", List()); - def unify1(x: Term, y: Term, s: Subst): Option[Subst] = Pair(x, y) match { - case Pair(Var(a), Var(b)) if (a == b) => + def unify1(x: Term, y: Term, s: Subst): Option[Subst] = (x, y) match { + case (Var(a), Var(b)) if (a == b) => Some(s) - case Pair(Var(a), _) => lookup(s, a) match { + case (Var(a), _) => lookup(s, a) match { case Some(x1) => unify(x1, y, s) case None => if (y.tyvars contains a) None else Some(Binding(a, y) :: s) } - case Pair(_, Var(b)) => lookup(s, b) match { + case (_, Var(b)) => lookup(s, b) match { case Some(y1) => unify(x, y1, s) case None => if (x.tyvars contains b) None else Some(Binding(b, x) :: s) } - case Pair(Con(a, xs), Con(b, ys)) if (a == b) => + case (Con(a, xs), Con(b, ys)) if (a == b) => unify(xs, ys, s) case _ => None } @@ -96,9 +96,9 @@ object Terms { ss } - def unify(xs: List[Term], ys: List[Term], s: Subst): Option[Subst] = Pair(xs, ys) match { - case Pair(List(), List()) => Some(s) - case Pair(x :: xs1, y :: ys1) => + def unify(xs: List[Term], ys: List[Term], s: Subst): Option[Subst] = (xs, ys) match { + case (List(), List()) => Some(s) + case (x :: xs1, y :: ys1) => unify(x, y, s) match { case Some(s1) => unify(xs1, ys1, s1) case None => None diff --git a/test/files/run/bugs.scala b/test/files/run/bugs.scala index ba8449c299..02849b5817 100644 --- a/test/files/run/bugs.scala +++ b/test/files/run/bugs.scala @@ -46,7 +46,7 @@ object Bug135Test { def test(args: Array[String]) { val myMap:TreeMap[Int, String] = new TreeMap - val map1 = myMap + Pair(42, "The answer") + val map1 = myMap + ((42, "The answer")) println(map1.get(42)) } diff --git a/test/files/run/ctries-old/main.scala b/test/files/run/ctries-old/main.scala index f714bcdcdc..77161fed2f 100644 --- a/test/files/run/ctries-old/main.scala +++ b/test/files/run/ctries-old/main.scala @@ -38,7 +38,7 @@ trait Spec { var produced = false try body catch { - case e: Throwable => if (e.getClass == implicitly[ClassManifest[T]].erasure) produced = true + case e: Throwable => if (e.getClass == implicitly[ClassManifest[T]].runtimeClass) produced = true } finally { assert(produced, "Did not produce exception of type: " + implicitly[ClassManifest[T]]) } diff --git a/test/files/run/getClassTest-old.scala b/test/files/run/getClassTest-old.scala index 789dd4d162..cd1b6b07f6 100644 --- a/test/files/run/getClassTest-old.scala +++ b/test/files/run/getClassTest-old.scala @@ -53,7 +53,7 @@ class MoreAnyRefs { @deprecated("Suppress warnings", since="2.11") object Test { def returnTypes[T: Manifest] = ( - manifest[T].erasure.getMethods.toList + manifest[T].runtimeClass.getMethods.toList filter (_.getName startsWith "f") sortBy (_.getName) map (m => m.getName + ": " + m.getGenericReturnType.toString) diff --git a/test/files/run/map_test.scala b/test/files/run/map_test.scala index 1ea864ed58..b76dfb4577 100644 --- a/test/files/run/map_test.scala +++ b/test/files/run/map_test.scala @@ -20,7 +20,7 @@ object Test extends App { val map2 = map1.updated(17,"A small random number") val map3 = map2.updated(666,"A bigger random number") val map4 = map3.updated(4711,"A big random number") - map1 == myMap + Pair(42, "The answer") + map1 == myMap + ((42, "The answer")) var i = 0 var map = map4 while(i < 43) { diff --git a/test/files/run/patmatnew.scala b/test/files/run/patmatnew.scala index b212e10f8d..3c0d00dc6c 100644 --- a/test/files/run/patmatnew.scala +++ b/test/files/run/patmatnew.scala @@ -46,7 +46,7 @@ object Test { object SimpleUnapply { def run() { // from sortedmap, old version List((1, 2)).head match { - case kv@Pair(key, _) => kv.toString + " " + key.toString + case kv@(key, _) => kv.toString + " " + key.toString } } @@ -400,9 +400,9 @@ object Test { // these are exhaustive matches // should not generate any warnings def f[A](z: (Option[A], Option[A])) = z match { - case Pair(None, Some(x)) => 1 - case Pair(Some(x), None) => 2 - case Pair(Some(x), Some(y)) => 3 + case (None, Some(x)) => 1 + case (Some(x), None) => 2 + case (Some(x), Some(y)) => 3 case _ => 4 } @@ -419,9 +419,9 @@ object Test { } def h[A](x: (Option[A], Option[A])) = x match { - case Pair(None, _: Some[_]) => 1 - case Pair(_: Some[_], None) => 2 - case Pair(_: Some[_], _: Some[_]) => 3 + case (None, _: Some[_]) => 1 + case (_: Some[_], None) => 2 + case (_: Some[_], _: Some[_]) => 3 case _ => 4 } @@ -539,17 +539,17 @@ object Test { case class Operator(x: Int); val EQ = new Operator(2); - def analyze(x: Pair[Operator, Int]) = x match { - case Pair(EQ, 0) => "0" - case Pair(EQ, 1) => "1" - case Pair(EQ, 2) => "2" + def analyze(x: Tuple2[Operator, Int]) = x match { + case (EQ, 0) => "0" + case (EQ, 1) => "1" + case (EQ, 2) => "2" } def run() { - val x = Pair(EQ, 0); + val x = (EQ, 0); assertEquals("0", analyze(x)); // should print "0" - val y = Pair(EQ, 1); + val y = (EQ, 1); assertEquals("1", analyze(y)); // should print "1" - val z = Pair(EQ, 2); + val z = (EQ, 2); assertEquals("2", analyze(z)); // should print "2" } } diff --git a/test/files/run/t3888.scala b/test/files/run/t3888.scala index 19771041fc..8701b42ff0 100644 --- a/test/files/run/t3888.scala +++ b/test/files/run/t3888.scala @@ -24,6 +24,6 @@ object Test { } } -class P extends Pair(1, 1) { +class P extends Tuple2(1, 1) { override def equals(x: Any) = true } diff --git a/test/files/run/t6329_repl_bug.check b/test/files/run/t6329_repl_bug.check new file mode 100644 index 0000000000..44c41cfd03 --- /dev/null +++ b/test/files/run/t6329_repl_bug.check @@ -0,0 +1,17 @@ +Type in expressions to have them evaluated. +Type :help for more information. + +scala> import scala.reflect.runtime.universe._ +import scala.reflect.runtime.universe._ + +scala> import scala.reflect.runtime._ +import scala.reflect.runtime._ + +scala> classManifest[List[_]] +warning: there were 1 deprecation warning(s); re-run with -deprecation for details +res0: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[<?>] + +scala> scala.reflect.classTag[List[_]] +res1: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List + +scala> diff --git a/test/files/run/t6329_repl_bug.pending b/test/files/run/t6329_repl_bug.scala index 9997d1771e..9997d1771e 100644 --- a/test/files/run/t6329_repl_bug.pending +++ b/test/files/run/t6329_repl_bug.scala diff --git a/test/files/run/t6329_vanilla_bug.check b/test/files/run/t6329_vanilla_bug.check new file mode 100644 index 0000000000..640d168a8a --- /dev/null +++ b/test/files/run/t6329_vanilla_bug.check @@ -0,0 +1,3 @@ +warning: there were 1 deprecation warning(s); re-run with -deprecation for details +scala.collection.immutable.List[<?>] +scala.collection.immutable.List diff --git a/test/files/run/t6329_vanilla_bug.pending b/test/files/run/t6329_vanilla_bug.scala index 404f90bf6e..404f90bf6e 100644 --- a/test/files/run/t6329_vanilla_bug.pending +++ b/test/files/run/t6329_vanilla_bug.scala diff --git a/test/files/run/t7985.scala b/test/files/run/t7985.scala new file mode 100644 index 0000000000..5fe270f9c0 --- /dev/null +++ b/test/files/run/t7985.scala @@ -0,0 +1,3 @@ +object Test extends App { + Array(1) match { case _: Array[scala.Int] => } +} diff --git a/test/files/run/t7985b.scala b/test/files/run/t7985b.scala new file mode 100644 index 0000000000..aaf649eb28 --- /dev/null +++ b/test/files/run/t7985b.scala @@ -0,0 +1,5 @@ +class a { type X = Int } + +object Test extends App { + Array(1) match { case _: Array[a#X] => } +} diff --git a/test/files/run/tailcalls.scala b/test/files/run/tailcalls.scala index e5d8891cc7..1653b14de9 100644 --- a/test/files/run/tailcalls.scala +++ b/test/files/run/tailcalls.scala @@ -169,7 +169,7 @@ class TailCall[S](s: S) { aux[T](x, y); } final def g3[T](x: Int, y: Int, zs: List[T]): Int = { - def aux[U](n: Int, v: Int, ls: List[Pair[T,U]]): Int = + def aux[U](n: Int, v: Int, ls: List[Tuple2[T,U]]): Int = if (n == 0) v else aux(n - 1, v - 1, ls); aux(x, y, Nil); } diff --git a/test/files/run/tcpoly_parseridioms.check b/test/files/run/tcpoly_parseridioms.check index ab829e0a0e..8bd0a086d6 100644 --- a/test/files/run/tcpoly_parseridioms.check +++ b/test/files/run/tcpoly_parseridioms.check @@ -4,8 +4,8 @@ It would fail on the following input: ParseResult() ^ tcpoly_parseridioms.scala:17: warning: match may not be exhaustive. It would fail on the following input: ParseResult() - def apply(in: Input): ParseResult[Pair[T, U]] = a(in) match { - ^ + def apply(in: Input): ParseResult[Tuple2[T, U]] = a(in) match { + ^ tcpoly_parseridioms.scala:30: warning: match may not be exhaustive. It would fail on the following input: ParseResult() case Failure(_, _) => b(in) match { diff --git a/test/files/run/tcpoly_parseridioms.scala b/test/files/run/tcpoly_parseridioms.scala index c8bcf693a1..d22f68b558 100644 --- a/test/files/run/tcpoly_parseridioms.scala +++ b/test/files/run/tcpoly_parseridioms.scala @@ -13,10 +13,10 @@ trait Parsers { } // sequence - def sq[T, U](a: => Parser[T], b: => Parser[U]): Parser[Pair[T, U]] = new Parser[Pair[T, U]] { - def apply(in: Input): ParseResult[Pair[T, U]] = a(in) match { + def sq[T, U](a: => Parser[T], b: => Parser[U]): Parser[Tuple2[T, U]] = new Parser[Tuple2[T, U]] { + def apply(in: Input): ParseResult[Tuple2[T, U]] = a(in) match { case Success(next, x) => b(next) match { - case Success(next2, y) => Success(next2, Pair(x,y)) + case Success(next2, y) => Success(next2, (x,y)) case Failure(_, msg) => Failure(in, msg) } case Failure(_, msg) => Failure(in, msg) @@ -49,7 +49,7 @@ trait Parsers { } } - def apply_++[s, tt](fun: Parser[s => tt], arg: Parser[s]): Parser[tt] = lift[Pair[s=>tt, s], tt]({case Pair(f, a) => f(a)})(sq(fun, arg)) + def apply_++[s, tt](fun: Parser[s => tt], arg: Parser[s]): Parser[tt] = lift[Tuple2[s=>tt, s], tt]({case (f, a) => f(a)})(sq(fun, arg)) def success[u](v: u): Parser[u] = new Parser[u] { def apply(in: Input) = Success(in, v) diff --git a/test/files/run/withIndex.scala b/test/files/run/withIndex.scala index 910b1f1f9e..ebf1941c95 100644 --- a/test/files/run/withIndex.scala +++ b/test/files/run/withIndex.scala @@ -11,7 +11,7 @@ object Test { Console.println(str.zipWithIndex.toList) assert { ary.zipWithIndex match { - case _: Array[Pair[_,_]] => true + case _: Array[Tuple2[_,_]] => true case _ => false } } diff --git a/test/files/scalacheck/CheckCollections.scala b/test/files/scalacheck/CheckCollections.scala index 108040b900..329d505b47 100644 --- a/test/files/scalacheck/CheckCollections.scala +++ b/test/files/scalacheck/CheckCollections.scala @@ -1,4 +1,4 @@ -import org.scalacheck.{ ConsoleReporter, Properties } +import org.scalacheck.Properties import org.scalacheck.Prop._ import scala.reflect.internal.util.Collections._ @@ -49,11 +49,4 @@ object Test extends Properties("reflect.internal.util.Collections") { for { (label, prop) <- tests } property(label) = prop - - import org.scalacheck.{ Test => STest } - - def runTests() = - STest.checkProperties( - STest.Params(testCallback = ConsoleReporter(0)), this) - } diff --git a/test/files/scalacheck/CheckEither.scala b/test/files/scalacheck/CheckEither.scala index 4d0cab4693..48f732a22d 100644 --- a/test/files/scalacheck/CheckEither.scala +++ b/test/files/scalacheck/CheckEither.scala @@ -1,10 +1,8 @@ -import org.scalacheck.{ Arbitrary, ConsoleReporter, Prop, Properties } +import org.scalacheck.{ Arbitrary, Prop, Properties } import org.scalacheck.Arbitrary.{arbitrary, arbThrowable} import org.scalacheck.Gen.oneOf -import org.scalacheck.util.StdRand import org.scalacheck.Prop._ -import org.scalacheck.Test.{Params, check} -import org.scalacheck.ConsoleReporter.testStatsEx +import org.scalacheck.Test.check import Function.tupled object Test extends Properties("Either") { @@ -178,10 +176,4 @@ object Test extends Properties("Either") { for ((label, prop) <- tests) { property(label) = prop } - - import org.scalacheck.{ Test => STest } - - def runTests() = { - STest.checkProperties(STest.Params(testCallback = ConsoleReporter(0)), this) - } } diff --git a/test/files/scalacheck/array-new.scala b/test/files/scalacheck/array-new.scala index e13a47a5d5..d8c69ead78 100644 --- a/test/files/scalacheck/array-new.scala +++ b/test/files/scalacheck/array-new.scala @@ -1,4 +1,4 @@ -import scala.reflect.{ClassTag, classTag} +import scala.reflect.ClassTag // new style: use ClassTag import org.scalacheck._ import Prop._ import Gen._ diff --git a/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala b/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala index c4b93dae48..7905a2ca15 100644 --- a/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala +++ b/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala @@ -222,7 +222,7 @@ trait ArbitraryTreesAndNames { yield ValDef(mods, name, tpt, rhs) def genTree(size: Int): Gen[Tree] = - if (size <= 1) oneOf(EmptyTree, genTreeIsTerm(size), genTreeIsType(size)) + if (size <= 1) oneOf(EmptyTree: Gen[Tree], genTreeIsTerm(size), genTreeIsType(size)) else oneOf(genTree(1), // these trees are neither terms nor types genPackageDef(size - 1), genModuleDef(size - 1), @@ -273,8 +273,8 @@ trait ArbitraryTreesAndNames { def apply(universe: Universe, value: TreeIsType): universe.Tree = value.tree.asInstanceOf[universe.Tree] } - implicit def treeIsTerm2tree(tit: TreeIsTerm) = tit.tree - implicit def treeIsType2tree(tit: TreeIsType) = tit.tree + implicit def treeIsTerm2tree(tit: TreeIsTerm): Tree = tit.tree + implicit def treeIsType2tree(tit: TreeIsType): Tree = tit.tree implicit val arbConstant: Arbitrary[Constant] = Arbitrary(genConstant) implicit val arbModifiers: Arbitrary[Modifiers] = Arbitrary(genModifiers) diff --git a/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala b/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala index b2bce124ee..b331c4b6b6 100644 --- a/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala +++ b/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala @@ -18,13 +18,12 @@ trait Helpers { object simplify extends Transformer { object SimplifiedName { - def unapply[T <: Name](name: T): Option[T] = - name.toString.split("\\$").toSeq match { - case first :+ last if scala.util.Try(last.toInt).isSuccess && first.nonEmpty => - val value = first.mkString("", "$", "$") - Some((if (name.isTermName) TermName(value) else TypeName(value)).asInstanceOf[T]) - case _ => None - } + val st = scala.reflect.runtime.universe.asInstanceOf[scala.reflect.internal.SymbolTable] + val FreshName = new st.FreshNameExtractor + def unapply[T <: Name](name: T): Option[T] = name.asInstanceOf[st.Name] match { + case FreshName(prefix) => + Some((if (name.isTermName) TermName(prefix) else TypeName(prefix)).asInstanceOf[T]) + } } override def transform(tree: Tree): Tree = tree match { @@ -59,7 +58,7 @@ trait Helpers { } def assertThrows[T <: AnyRef](f: => Any)(implicit manifest: Manifest[T]): Unit = { - val clazz = manifest.erasure.asInstanceOf[Class[T]] + val clazz = manifest.runtimeClass.asInstanceOf[Class[T]] val thrown = try { f diff --git a/test/files/scalacheck/si4147.scala b/test/files/scalacheck/si4147.scala index 05507b1b18..72f6e9afd5 100644 --- a/test/files/scalacheck/si4147.scala +++ b/test/files/scalacheck/si4147.scala @@ -1,8 +1,6 @@ import org.scalacheck.Prop.{forAll, throws} import org.scalacheck.Properties -import org.scalacheck.ConsoleReporter.testStatsEx import org.scalacheck.Gen -import org.scalacheck.ConsoleReporter import collection.mutable @@ -66,5 +64,5 @@ object Test extends Properties("Mutable TreeSet") { } property("ordering must not be null") = - throws(mutable.TreeSet.empty[Int](null), classOf[NullPointerException]) + throws(classOf[NullPointerException])(mutable.TreeSet.empty[Int](null)) } diff --git a/test/files/scalacheck/t2460.scala b/test/files/scalacheck/t2460.scala index 196b43789f..ab2911447a 100644 --- a/test/files/scalacheck/t2460.scala +++ b/test/files/scalacheck/t2460.scala @@ -1,6 +1,5 @@ import org.scalacheck.Prop.forAll import org.scalacheck.Properties -import org.scalacheck.ConsoleReporter.testStatsEx import org.scalacheck.{Test => SCTest} import org.scalacheck.Gen @@ -25,8 +24,4 @@ object Test extends Properties("Regex : Ticket 2460") { ("numberOfGroup", numberOfGroup), ("nameOfGroup", nameOfGroup) ) - - /*tests foreach { - case (name, p) => testStatsEx(name, SCTest.check(p)) - }*/ } diff --git a/test/files/scalacheck/treeset.scala b/test/files/scalacheck/treeset.scala index 7fca3ed5e4..4b9b77dd7e 100644 --- a/test/files/scalacheck/treeset.scala +++ b/test/files/scalacheck/treeset.scala @@ -151,5 +151,5 @@ object Test extends Properties("TreeSet") { } property("ordering must not be null") = - throws(TreeSet.empty[Int](null), classOf[NullPointerException]) + throws(classOf[NullPointerException])(TreeSet.empty[Int](null)) } diff --git a/test/junit/scala/tools/nsc/symtab/FreshNameExtractorTest.scala b/test/junit/scala/tools/nsc/symtab/FreshNameExtractorTest.scala new file mode 100644 index 0000000000..cf09abdfff --- /dev/null +++ b/test/junit/scala/tools/nsc/symtab/FreshNameExtractorTest.scala @@ -0,0 +1,47 @@ +package scala.tools.nsc +package symtab + +import org.junit.Assert._ +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 + +import scala.tools.testing.AssertUtil.assertThrows +import scala.reflect.internal.util.FreshNameCreator + +@RunWith(classOf[JUnit4]) +class FreshNameExtractorTest { + object symbolTable extends SymbolTableForUnitTesting + import symbolTable._ + + val prefixes = List("foo$", "x$", "bar", "bippy$baz$") + + @Test + def extractionPreservesPrefix = + ("" :: prefixes).foreach { creatorPrefix => + prefixes.foreach { newPrefix => + val Creator = new FreshNameCreator(creatorPrefix) + val Extractor = new FreshNameExtractor(creatorPrefix) + val Extractor(extractedPrefix) = TermName(Creator.newName(newPrefix)) + assertEquals(newPrefix, extractedPrefix) + } + } + + @Test + def extractionFailsOnCreatorPrefixMismatch = { + val Creator = new FreshNameCreator(prefixes.head) + val Extractor = new FreshNameExtractor(prefixes.tail.head) + assertThrows[MatchError] { + val Extractor(_) = TermName(Creator.newName("foo")) + } + } + + @Test + def extractionsFailsIfNameDoesntEndWithNumber = { + val Creator = new FreshNameCreator(prefixes.head) + val Extractor = new FreshNameExtractor(prefixes.head) + assertThrows[MatchError] { + val Extractor(_) = TermName(Creator.newName("foo") + "bar") + } + } +}
\ No newline at end of file diff --git a/test/pending/run/reify_callccinterpreter.scala b/test/pending/run/reify_callccinterpreter.scala index d9f7736769..82c70da28f 100644 --- a/test/pending/run/reify_callccinterpreter.scala +++ b/test/pending/run/reify_callccinterpreter.scala @@ -43,15 +43,15 @@ object Test extends App { override def toString() = "<function>" } - type Environment = List[Pair[Name, Value]]; + type Environment = List[Tuple2[Name, Value]]; def lookup(x: Name, e: Environment): M[Value] = e match { case List() => unitM(Wrong) - case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) + case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) } - def add(a: Value, b: Value): M[Value] = Pair(a, b) match { - case Pair(Num(m), Num(n)) => unitM(Num(m + n)) + def add(a: Value, b: Value): M[Value] = (a, b) match { + case (Num(m), Num(n)) => unitM(Num(m + n)) case _ => unitM(Wrong) } @@ -67,12 +67,12 @@ object Test extends App { b <- interp(r, e); c <- add(a, b)) yield c - case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e))) + case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e))) case App(f, t) => for (a <- interp(f, e); b <- interp(t, e); c <- apply(a, b)) yield c - case Ccc(x, t) => callCC(k => interp(t, Pair(x, Fun(k)) :: e)) + case Ccc(x, t) => callCC(k => interp(t, (x, Fun(k)) :: e)) } def test(t: Term): String = showM(interp(t, List())) diff --git a/test/pending/run/reify_simpleinterpreter.scala b/test/pending/run/reify_simpleinterpreter.scala index 6cf87ea7c5..1f6d6c8da7 100644 --- a/test/pending/run/reify_simpleinterpreter.scala +++ b/test/pending/run/reify_simpleinterpreter.scala @@ -32,15 +32,15 @@ object Test extends App { override def toString() = "<function>" } - type Environment = List[Pair[Name, Value]] + type Environment = List[Tuple2[Name, Value]] def lookup(x: Name, e: Environment): M[Value] = e match { case List() => unitM(Wrong) - case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) + case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) } - def add(a: Value, b: Value): M[Value] = Pair(a, b) match { - case Pair(Num(m), Num(n)) => unitM(Num(m + n)) + def add(a: Value, b: Value): M[Value] = (a, b) match { + case (Num(m), Num(n)) => unitM(Num(m + n)) case _ => unitM(Wrong) } @@ -56,7 +56,7 @@ object Test extends App { b <- interp(r, e); c <- add(a, b)) yield c - case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e))) + case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e))) case App(f, t) => for (a <- interp(f, e); b <- interp(t, e); c <- apply(a, b)) diff --git a/test/pending/shootout/fasta.scala b/test/pending/shootout/fasta.scala index 8b711083a5..ae99ba5936 100644 --- a/test/pending/shootout/fasta.scala +++ b/test/pending/shootout/fasta.scala @@ -5,7 +5,7 @@ import java.io._ -object fasta { +object fasta { def main(args: Array[String]) = { val ALU = @@ -18,31 +18,31 @@ object fasta { "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA" val _IUB = Array( - Pair('a', 0.27), - Pair('c', 0.12), - Pair('g', 0.12), - Pair('t', 0.27), - - Pair('B', 0.02), - Pair('D', 0.02), - Pair('H', 0.02), - Pair('K', 0.02), - Pair('M', 0.02), - Pair('N', 0.02), - Pair('R', 0.02), - Pair('S', 0.02), - Pair('V', 0.02), - Pair('W', 0.02), - Pair('Y', 0.02) + ('a', 0.27), + ('c', 0.12), + ('g', 0.12), + ('t', 0.27), + + ('B', 0.02), + ('D', 0.02), + ('H', 0.02), + ('K', 0.02), + ('M', 0.02), + ('N', 0.02), + ('R', 0.02), + ('S', 0.02), + ('V', 0.02), + ('W', 0.02), + ('Y', 0.02) ) val IUB = makeCumulative(_IUB) val _HomoSapiens = Array( - Pair('a', 0.3029549426680), - Pair('c', 0.1979883004921), - Pair('g', 0.1975473066391), - Pair('t', 0.3015094502008) + ('a', 0.3029549426680), + ('c', 0.1979883004921), + ('g', 0.1975473066391), + ('t', 0.3015094502008) ) val HomoSapiens = makeCumulative(_HomoSapiens) @@ -61,15 +61,15 @@ object fasta { s.writeRandomSequence(HomoSapiens,n*5) s.close - } + } - def makeCumulative(a: Array[Pair[Char,Double]]) = { + def makeCumulative(a: Array[Tuple2[Char,Double]]) = { var cp = 0.0 a map (frequency => - frequency match { - case Pair(code,percent) => - cp = cp + percent; new Frequency(code.toByte,cp) - } + frequency match { + case (code,percent) => + cp = cp + percent; new Frequency(code.toByte,cp) + } ) } @@ -79,7 +79,7 @@ object fasta { // We could use instances of Pair or Tuple2 but specific labels // make the code more readable than index numbers -class Frequency(_code: Byte, _percent: Double){ +class Frequency(_code: Byte, _percent: Double){ var code = _code; var percent = _percent; } @@ -101,13 +101,13 @@ class FastaOutputStream(out: OutputStream) extends BufferedOutputStream(out) { val m = if (n < LineLength) n else LineLength var i = 0 - while (i < m){ + while (i < m){ if (k == kn) k = 0 val b = alu(k) if (count < buf.length){ buf(count) = b; count = count + 1 } else { write(b) } // flush buffer k = k+1 - i = i+1 + i = i+1 } write(nl) @@ -122,11 +122,11 @@ class FastaOutputStream(out: OutputStream) extends BufferedOutputStream(out) { val m = if (n < LineLength) n else LineLength var i = 0 - while (i < m){ + while (i < m){ val b = selectRandom(distribution) if (count < buf.length){ buf(count) = b; count = count + 1 } else { write(b) } // flush buffer - i = i+1 + i = i+1 } if (count < buf.length){ buf(count) = nl; count = count + 1 } diff --git a/test/pending/shootout/revcomp.scala-2.scala b/test/pending/shootout/revcomp.scala-2.scala index 92260ad021..03fb25af1b 100644 --- a/test/pending/shootout/revcomp.scala-2.scala +++ b/test/pending/shootout/revcomp.scala-2.scala @@ -6,7 +6,7 @@ import java.io._ import scala.collection.mutable.Stack -object revcomp { +object revcomp { val IUB = IUBCodeComplements @@ -16,7 +16,7 @@ object revcomp { val a: Array[Byte] = new Array( 'z'.toByte ) for (indexValue <- code zip comp) - indexValue match { case Pair(i,v) => a(i) = v } + indexValue match { case (i,v) => a(i) = v } a } @@ -49,18 +49,18 @@ object revcomp { if (desc.length > 0) complementReverseWrite(desc, lines, w) w.close - } + } - def complementReverseWrite(desc: String, lines: LineStack, + def complementReverseWrite(desc: String, lines: LineStack, w: BufferedOutputStream) = { def inplaceComplementReverse(b: Array[Byte]) = { - var i = 0 + var i = 0 var j = b.length - 1 while (i < j){ - val swap = b(i) - b(i) = IUB( b(j) ) + val swap = b(i) + b(i) = IUB( b(j) ) b(j) = IUB( swap ) i = i + 1 j = j - 1 @@ -79,11 +79,11 @@ object revcomp { while (!lines.isEmpty) { val line = lines.pop inplaceComplementReverse(line) - + if (isSplitLine){ if (isFirstLine){ w.write(line); isFirstLine = false } else { w.write(line,0,n-k); w.write(nl); w.write(line,n-k,k) } - } + } else { w.write(line); w.write(nl) } } if (isSplitLine && !isFirstLine) w.write(nl) diff --git a/test/pending/shootout/revcomp.scala-3.scala b/test/pending/shootout/revcomp.scala-3.scala index ae12f0499b..39a0409127 100644 --- a/test/pending/shootout/revcomp.scala-3.scala +++ b/test/pending/shootout/revcomp.scala-3.scala @@ -6,7 +6,7 @@ import java.io._ import scala.collection.mutable.Stack -object revcomp { +object revcomp { def main(args: Array[String]) = { val out = new FastaOutputStream(System.out) val in = new FastaInputStream(System.in) @@ -17,12 +17,12 @@ object revcomp { in.close out.close - } + } } trait FastaByteStream { - val nl = '\n'.toByte + val nl = '\n'.toByte type Line = Array[Byte] type LineStack = Stack[Line] @@ -31,13 +31,13 @@ trait FastaByteStream { // extend the Java BufferedInputStream class -final class FastaInputStream(in: InputStream) +final class FastaInputStream(in: InputStream) extends BufferedInputStream(in) with FastaByteStream { val gt = '>'.toByte val sc = ';'.toByte - def readSequenceStack(): Pair[Line,LineStack] = { + def readSequenceStack(): Tuple2[Line,LineStack] = { var header: Line = null val lines: LineStack = new Stack @@ -49,14 +49,14 @@ final class FastaInputStream(in: InputStream) header = line } else { pos = pos - line.length - 1 // reposition to start of line - return Pair(header,lines) + return (header,lines) } } else { if (c != sc) lines push line // ';' } line = readLine() } - return Pair(header,lines) + return (header,lines) } def readLine() = { @@ -65,7 +65,7 @@ final class FastaInputStream(in: InputStream) else { mark(128) // mark the start of the line if (count == 0) read() // fill buffer - + var i = markpos while (i < count && buf(i) != nl) i = i + 1 @@ -74,11 +74,11 @@ final class FastaInputStream(in: InputStream) while (i < count && buf(i) != nl) i = i + 1 } - if (i < count){ + if (i < count){ bytes = new Array(i - markpos) System.arraycopy(buf, markpos, bytes, 0, i - markpos); pos = i+1 - } + } } bytes } @@ -87,7 +87,7 @@ final class FastaInputStream(in: InputStream) // extend the Java BufferedOutputStream class -final class FastaOutputStream(in: OutputStream) +final class FastaOutputStream(in: OutputStream) extends BufferedOutputStream(in) with FastaByteStream { private val IUB = IUBCodeComplements @@ -98,19 +98,19 @@ final class FastaOutputStream(in: OutputStream) val iub: Array[Byte] = new Array( 'z'.toByte ) for (indexValue <- code zip comp) - indexValue match { case Pair(i,v) => iub(i) = v } + indexValue match { case (i,v) => iub(i) = v } iub } - def writeReverseComplement(sequence: Pair[Line,LineStack]) = { + def writeReverseComplement(sequence: Tuple2[Line,LineStack]) = { def inplaceComplementReverse(b: Array[Byte]) = { - var i = 0 + var i = 0 var j = b.length - 1 while (i < j){ - val swap = b(i) - b(i) = IUB( b(j) ) + val swap = b(i) + b(i) = IUB( b(j) ) b(j) = IUB( swap ) i = i + 1 j = j - 1 @@ -119,7 +119,7 @@ final class FastaOutputStream(in: OutputStream) } sequence match { - case Pair(header,lines) => { + case (header,lines) => { write(header); write(nl) @@ -131,11 +131,11 @@ final class FastaOutputStream(in: OutputStream) while (!lines.isEmpty) { val line = lines.pop inplaceComplementReverse(line) - + if (isSplitLine){ - if (isFirstLine){ write(line); isFirstLine = false } + if (isFirstLine){ write(line); isFirstLine = false } else { write(line,0,LineLength-k); write(nl); write(line,LineLength-k,k) } - } + } else { write(line); write(nl) } } |