diff options
Diffstat (limited to 'test/files')
819 files changed, 19652 insertions, 1375 deletions
diff --git a/test/files/jvm/beanInfo.check b/test/files/jvm/beanInfo.check new file mode 100644 index 0000000000..d74e127711 --- /dev/null +++ b/test/files/jvm/beanInfo.check @@ -0,0 +1,6 @@ +property descriptors +x -- int -- public int p.C.x() -- null +y -- class java.lang.String -- public java.lang.String p.C.y() -- public void p.C.y_$eq(java.lang.String) +z -- class scala.collection.immutable.List -- public scala.collection.immutable.List p.C.z() -- public void p.C.z_$eq(scala.collection.immutable.List) +method descriptors +f -- public p.C p.C.f() diff --git a/test/files/jvm/beanInfo/C_1.scala b/test/files/jvm/beanInfo/C_1.scala new file mode 100644 index 0000000000..a338abea1d --- /dev/null +++ b/test/files/jvm/beanInfo/C_1.scala @@ -0,0 +1,9 @@ +package p + +@scala.beans.BeanInfo +class C { + val x: Int = 0 + var y: String = "" + var z: List[_] = Nil + def f: C = ??? +} diff --git a/test/files/jvm/beanInfo/Test_2.scala b/test/files/jvm/beanInfo/Test_2.scala new file mode 100644 index 0000000000..fa9b6e1391 --- /dev/null +++ b/test/files/jvm/beanInfo/Test_2.scala @@ -0,0 +1,17 @@ +object Test extends App { + val info = java.beans.Introspector.getBeanInfo(classOf[p.C]) + + println("property descriptors") + + val pds = info.getPropertyDescriptors + for (pd <- pds) { + println(s"${pd.getName} -- ${pd.getPropertyType} -- ${pd.getReadMethod} -- ${pd.getWriteMethod}") + } + + println("method descriptors") + + val mds = info.getMethodDescriptors + for (md <- mds) { + println(s"${md.getName} -- ${md.getMethod}") + } +} diff --git a/test/files/jvm/deprecation.check b/test/files/jvm/deprecation.check index d116778d3f..d57b6b55a5 100644 --- a/test/files/jvm/deprecation.check +++ b/test/files/jvm/deprecation.check @@ -1,3 +1,3 @@ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details Note: deprecation/Use_2.java uses or overrides a deprecated API. Note: Recompile with -Xlint:deprecation for details. diff --git a/test/files/jvm/duration-tck.scala b/test/files/jvm/duration-tck.scala index 3bc8a2c100..7db6c49964 100644 --- a/test/files/jvm/duration-tck.scala +++ b/test/files/jvm/duration-tck.scala @@ -61,6 +61,11 @@ object Test extends App { minf - inf mustBe minf minf + minf mustBe minf + for (i <- Seq(zero, one, two, three)) { + i - inf mustBe minf + i - minf mustBe inf + } + inf.compareTo(inf) mustBe 0 inf.compareTo(one) mustBe 1 inf.compareTo(minf) mustBe 1 diff --git a/test/files/jvm/future-spec.check b/test/files/jvm/future-spec.check index 844ca54682..df1629dd7e 100644 --- a/test/files/jvm/future-spec.check +++ b/test/files/jvm/future-spec.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details diff --git a/test/files/jvm/future-spec/PromiseTests.scala b/test/files/jvm/future-spec/PromiseTests.scala index 12b9168c5d..67c8c542ba 100644 --- a/test/files/jvm/future-spec/PromiseTests.scala +++ b/test/files/jvm/future-spec/PromiseTests.scala @@ -44,20 +44,79 @@ class PromiseTests extends MinimalScalaTest { }.getMessage mustBe ("br0ken") } + "be completable with a completed Promise" in { + { + val p = Promise[String]() + p.tryCompleteWith(Promise[String]().success("foo").future) + Await.result(p.future, defaultTimeout) mustBe ("foo") + } + { + val p = Promise[String]() + p.completeWith(Promise[String]().success("foo").future) + Await.result(p.future, defaultTimeout) mustBe ("foo") + } + { + val p = Promise[String]() + p.tryCompleteWith(Promise[String]().failure(new RuntimeException("br0ken")).future) + intercept[RuntimeException] { + Await.result(p.future, defaultTimeout) + }.getMessage mustBe ("br0ken") + } + { + val p = Promise[String]() + p.tryCompleteWith(Promise[String]().failure(new RuntimeException("br0ken")).future) + intercept[RuntimeException] { + Await.result(p.future, defaultTimeout) + }.getMessage mustBe ("br0ken") + } + } } "A successful Promise" should { - val result = "test value" - val promise = Promise[String]().complete(Success(result)) - promise.isCompleted mustBe (true) - futureWithResult(_(promise.future, result)) + "be completed" in { + val result = "test value" + val promise = Promise[String]().complete(Success(result)) + promise.isCompleted mustBe (true) + futureWithResult(_(promise.future, result)) + } + + "not be completable with a completed Promise" in { + { + val p = Promise.successful("bar") + p.tryCompleteWith(Promise[String]().success("foo").future) + Await.result(p.future, defaultTimeout) mustBe ("bar") + } + { + val p = Promise.successful("bar") + p.completeWith(Promise[String]().success("foo").future) + Await.result(p.future, defaultTimeout) mustBe ("bar") + } + } } "A failed Promise" should { - val message = "Expected Exception" - val promise = Promise[String]().complete(Failure(new RuntimeException(message))) - promise.isCompleted mustBe (true) - futureWithException[RuntimeException](_(promise.future, message)) + "be completed" in { + val message = "Expected Exception" + val promise = Promise[String]().complete(Failure(new RuntimeException(message))) + promise.isCompleted mustBe (true) + futureWithException[RuntimeException](_(promise.future, message)) + } + "not be completable with a completed Promise" in { + { + val p = Promise[String]().failure(new RuntimeException("unbr0ken")) + p.tryCompleteWith(Promise[String].failure(new Exception("br0ken")).future) + intercept[RuntimeException] { + Await.result(p.future, defaultTimeout) + }.getMessage mustBe ("unbr0ken") + } + { + val p = Promise[String]().failure(new RuntimeException("unbr0ken")) + p.completeWith(Promise[String]().failure(new Exception("br0ken")).future) + intercept[RuntimeException] { + Await.result(p.future, defaultTimeout) + }.getMessage mustBe ("unbr0ken") + } + } } "An interrupted Promise" should { diff --git a/test/files/jvm/inner.scala b/test/files/jvm/inner.scala index c05e803449..dc01b124c5 100644 --- a/test/files/jvm/inner.scala +++ b/test/files/jvm/inner.scala @@ -77,7 +77,7 @@ object Scalatest { def java(cname: String) = exec(javacmd, "-cp", classpath, cname) - /** Execute cmd, wait for the process to end and pipe it's output to stdout */ + /** Execute cmd, wait for the process to end and pipe its output to stdout */ private def exec(args: String*) { val proc = Runtime.getRuntime().exec(args.toArray) val inp = new BufferedReader(new InputStreamReader(proc.getInputStream)) diff --git a/test/files/jvm/innerClassAttribute.check b/test/files/jvm/innerClassAttribute.check new file mode 100644 index 0000000000..bb532e4f36 --- /dev/null +++ b/test/files/jvm/innerClassAttribute.check @@ -0,0 +1,54 @@ +#partest !-Ydelambdafy:method +-- A4 -- +A4$$anonfun$f$1 / null / null / 17 +A4$$anonfun$f$1 / null / null / 17 +A4 / f / (Lscala/collection/immutable/List;)Lscala/collection/immutable/List; +-- A19 -- +A19$$anonfun$1 / null / null / 17 +A19$$anonfun$2 / null / null / 17 +A19$$anonfun$3 / null / null / 17 +A19$$anonfun$1 / null / null / 17 +A19$$anonfun$2 / null / null / 17 +A19$$anonfun$3 / null / null / 17 +A19 / null / null +A19 / null / null +A19 / null / null +-- A20 -- +A20$$anonfun$6 / null / null / 17 +fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1` +A20$$anonfun$6 / null / null / 17 +A20$$anonfun$6$$anonfun$apply$1 / null / null / 17 +A20$$anonfun$6$$anonfun$apply$3 / null / null / 17 +fun2 () => (): itself and the outer closure +A20$$anonfun$6 / null / null / 17 +A20$$anonfun$6$$anonfun$apply$1 / null / null / 17 +fun3 () => () => (): itself, the outer closure and its child closure +A20$$anonfun$6 / null / null / 17 +A20$$anonfun$6$$anonfun$apply$3 / null / null / 17 +A20$$anonfun$6$$anonfun$apply$3$$anonfun$apply$2 / null / null / 17 +fun4: () => 1: itself and the two outer closures +A20$$anonfun$6 / null / null / 17 +A20$$anonfun$6$$anonfun$apply$3 / null / null / 17 +A20$$anonfun$6$$anonfun$apply$3$$anonfun$apply$2 / null / null / 17 +enclosing: nested closures have outer class defined, but no outer method +A20 / null / null +A20$$anonfun$6 / null / null +A20$$anonfun$6 / null / null +A20$$anonfun$6$$anonfun$apply$3 / null / null +#partest -Ydelambdafy:method +-- A4 -- +null / null / null +-- A19 -- +null / null / null +null / null / null +null / null / null +-- A20 -- +fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1` +fun2 () => (): itself and the outer closure +fun3 () => () => (): itself, the outer closure and its child closure +fun4: () => 1: itself and the two outer closures +enclosing: nested closures have outer class defined, but no outer method +null / null / null +null / null / null +null / null / null +null / null / null diff --git a/test/files/jvm/innerClassAttribute/Classes_1.scala b/test/files/jvm/innerClassAttribute/Classes_1.scala new file mode 100644 index 0000000000..fb1f32aa3d --- /dev/null +++ b/test/files/jvm/innerClassAttribute/Classes_1.scala @@ -0,0 +1,297 @@ +class A1 { + class B +} + +class A2 { + object B +} + +object A3 { + class B1 + object B2 +} + +class A4 { + def f(l: List[Int]): List[Int] = { + l map (_ + 1) + } +} + +class A5 { + def f(): Object = { + object B + B + } +} + +trait A6 { + def hui = -6 + trait TT +} + +class A7 extends A6 + +abstract class A8 extends A6 { + def fish: TT +} + +class A9 { + class brick extends annotation.StaticAnnotation +} + +class A10 { + val a9 = new A9() + // there's no reference to brick in the bytecode (only in the pickle), so there's no InnerClass attribute for it. + @a9.brick def f = -7 +} + +class A11 { + @JavaAnnot_1.Ann def f = -8 +} + +object A12 { + object B { + class C + } +} + +class A13 { + def oak: A12.B.C = new A12.B.C +} + +class A14 { + def f = { + val x: Object = { + class K + new K + } + x + } + def g = { + val x: Object = new A6 { } + } +} + +object A15 { + def f = { + class B { // non-static, even though it doesn't have an outer pointer + class C // non-static + } + } +} + +class A16 { + val x: A6 = { + class U extends A6 + new A6 { } + } + + { + class V extends A6 + new A6 { } + } + + new A6 { } +} + +class A17 { + object B { + class C // not static, also has an outer pointer. + } +} + +class A18 { + def f = { + def g = { + class A + new A6 { } + val y = { + if ((new Object).hashCode() == 1) {class B {} ; new B} else 2 + if ((new Object).hashCode() == 1) new A6 { } else "haifish" + } + } + } +} + +class A19 { + ((x: Int) => x + 3) + + val x = { + ((x: Int) => x + 1) + } + + { + ((x: Int) => x + 2) + } +} + +class A20 { + () => { + {() => ()} + {() => () => 1} + } +} + +class A21 { + class I1 + def f = { class J1 } +} +object A21 { + class I2 + object I3 { + class J2 // static + } + def g = { class J3 } // non-static + val x = { class J4 } // non-static + { + class J5 // non-static (!) + new J5 + } +} + +class A22 { + class C + object C { + class D // inner class of C$, not of C. Not added to the inner class table of C, only to C$ + } +} + +class A23 { + def f = { + val a = new Java_A_1() + val c = new Java_A_1.C() + val d = new Java_A_1.C.D() + val e = new c.E() + val f = new a.F() + val g = new f.G() + } +} + +trait A24Sym + +trait A24Base { + // trait with concrete members: interface plus (absract) impl class + trait DefinitionsApi { + def Abs: A24Sym + def Conc: A24Sym = new A24Sym { } + } +} + +trait A24 extends A24Base { + class DefinitionsClass extends DefinitionsApi { + // bridge methods are generated for Abs and Conc. there used to be a bug: the bridge symbol was a ModuleSymbol, + // calling companionClass would return NoSymbol. i changed erasure to make the bridge symbol is a MethodSymbol. + object Abs extends A24Sym + override object Conc extends A24Sym + } +} + +class SI_9105 { + // the EnclosingMethod attributes depend on the delambdafy strategy (inline vs method) + + // outerClass-inline enclMeth-inline outerClass-method enclMeth-method + val fun = () => { + class A // closure null (*) SI_9105 null + def m: Object = { class B; new B } // closure m$1 SI_9105 m$1 + val f: Object = { class C; new C } // closure null (*) SI_9105 null + } + def met = () => { + class D // closure null (*) SI_9105 met + def m: Object = { class E; new E } // closure m$1 SI_9105 m$1 + val f: Object = { class F; new F } // closure null (*) SI_9105 met + } + + // (*) the originalOwner chain of A (similar for D) is: SI_9105.fun.$anonfun-value.A + // we can get to the anonfun-class (created by uncurry), but not to the apply method. + // + // for C and F, the originalOwner chain is fun.$anonfun-value.f.C. at later phases, the rawowner of f is + // an apply$sp method of the closure class. we could use that as enclosing method, but it would be unsystematic + // (A / D don't have an encl meth either), and also strange to use the $sp, which is a compilation artifact. + // So using `null` looks more like the situation in the source code: C / F are nested classes of the anon-fun, and + // there's no method in between. + + def byName[T](op: => T) = 0 + + val bnV = byName { + class G // closure null (*) SI_9105 null + def m: Object = { class H; new H } // closure m$1 SI_9105 m$1 + val f: Object = { class I; new I } // closure null (*) SI_9105 null + } + def bnM = byName { + class J // closure null (*) SI_9105 bnM + def m: Object = { class K; new K } // closure m$1 SI_9105 m$1 + val f: Object = { class L; new L } // closure null (*) SI_9105 bnM + } +} + +trait SI_9124 { + trait A // member class, no enclosing method attribute + + new A { def f1 = 0 } // nested class, enclosing class SI_9124, no encl meth + + def f = new A { def f2 = 0 } // enclosing method is f in the interface SI_9124 + + private def g = new A { def f3 = 0 } // only encl class (SI_9124), encl meth is null because the interface SI_9124 doesn't have a method g + + object O { // member, no encl meth attribute + new A { def f4 = 0 } // enclosing class is O$, no enclosing method + } + + val f1 = { new A { def f5 = 0 }; 1 } // encl class SI_9124, no encl meth + private val f2 = { new A { def f6 = 0 }; 1 } // like above +} + +trait ImplClassesAreTopLevel { + // all impl classes are top-level, so they don't appear in any InnerClass entry, and none of them have an EnclosingMethod attr + trait B1 { def f = 1 } + { trait B2 { def f = 1 }; new B2 {} } + val m = { + trait B3 { def f = 1 } + new B3 {} + } + def n = { + trait B4 { def f = 1 } + new B4 {} + } +} + +class SpecializedClassesAreTopLevel { + // all specialized classes are top-level + class A[@specialized(Int) T]; new A[Int] + + object T { + class B[@specialized(Int) T]; new B[Int] + } + + // these crash the compiler, SI-7625 + + // { class B[@specialized(Int) T]; new B[Int] } + + // val m: Object = { + // class C[@specialized(Int) T] + // new C[Int] + // } + + // def n: Object = { + // class D[@specialized(Int) T] + // new D[Int] + // } +} + +object NestedInValueClass { + // note that we can only test anonymous functions, nested classes are not allowed inside value classes + class A(val arg: String) extends AnyVal { + // A has InnerClass entries for the two closures (and for A and A$). not for B / C + def f = { + def g = List().map(x => (() => x)) // outer class A, no outer method (g is moved to the companion, doesn't exist in A) + g.map(x => (() => x)) // outer class A, outer method f + } + // statements and field declarations are not allowed in value classes + } + + object A { + // A$ has InnerClass entries for B, C, A, A$. Also for the closures above, because they are referenced in A$'s bytecode. + class B // member class of A$ + def f = { class C; new C } // outer class A$, outer method f + } +} diff --git a/test/files/jvm/innerClassAttribute/JavaAnnot_1.java b/test/files/jvm/innerClassAttribute/JavaAnnot_1.java new file mode 100644 index 0000000000..27c4d4e5d3 --- /dev/null +++ b/test/files/jvm/innerClassAttribute/JavaAnnot_1.java @@ -0,0 +1,3 @@ +public class JavaAnnot_1 { + public static @interface Ann {} +} diff --git a/test/files/jvm/innerClassAttribute/Java_A_1.java b/test/files/jvm/innerClassAttribute/Java_A_1.java new file mode 100644 index 0000000000..3357d05e2b --- /dev/null +++ b/test/files/jvm/innerClassAttribute/Java_A_1.java @@ -0,0 +1,10 @@ +public class Java_A_1 { + public static class C { + public static class D { } + public class E { } + } + + public class F { + public class G { } + } +} diff --git a/test/files/jvm/innerClassAttribute/Test.scala b/test/files/jvm/innerClassAttribute/Test.scala new file mode 100644 index 0000000000..bc9aa2376a --- /dev/null +++ b/test/files/jvm/innerClassAttribute/Test.scala @@ -0,0 +1,592 @@ +import scala.tools.partest.BytecodeTest +import scala.tools.asm +import asm.tree.{ClassNode, InnerClassNode} +import asm.{Opcodes => Flags} +import scala.collection.JavaConverters._ + +object Test extends BytecodeTest { + def assertSame(a: Any, b: Any) = { + assert(a == b, s"\na: $a\nb: $b") + } + + val publicStatic = Flags.ACC_PUBLIC | Flags.ACC_STATIC + val publicAbstractInterface = Flags.ACC_PUBLIC | Flags.ACC_ABSTRACT | Flags.ACC_INTERFACE + + def innerClassNodes(className: String): List[InnerClassNode] = { + loadClassNode(className).innerClasses.asScala.toList.sortBy(_.name) + } + + def ownInnerClassNode(n: String) = innerClassNodes(n).filter(_.name == n).head + + def testInner(cls: String, fs: (InnerClassNode => Unit)*) = { + val ns = innerClassNodes(cls) + assert(ns.length == fs.length, ns) + (ns zip fs.toList) foreach { case (n, f) => f(n) } + } + + + + final case class EnclosingMethod(name: String, descriptor: String, outerClass: String) + def enclosingMethod(className: String) = { + val n = loadClassNode(className) + EnclosingMethod(n.outerMethod, n.outerMethodDesc, n.outerClass) + } + + def assertMember(node: InnerClassNode, outer: String, inner: String, name: Option[String] = None, flags: Int = Flags.ACC_PUBLIC) = { + assertSame(node.name, name.getOrElse(s"$outer$$$inner")) + assertSame(node.outerName, outer) + assertSame(node.innerName, inner) + assertSame(node.access, flags) + } + + def assertAnonymous(node: InnerClassNode, name: String, flags: Int = Flags.ACC_PUBLIC | Flags.ACC_FINAL) = { + assertSame(node.name, name) + assertSame(node.outerName, null) + assertSame(node.innerName, null) + assertSame(node.access, flags) + } + + def assertLocal(node: InnerClassNode, name: String, inner: String, flags: Int = Flags.ACC_PUBLIC) = { + assertSame(node.name, name) + assertSame(node.outerName, null) + assertSame(node.innerName, inner) + assertSame(node.access, flags) + } + + def assertEnclosingMethod(className: String, outerClass: String, name: String, descriptor: String) = { + val encl = enclosingMethod(className) + assertSame(encl.outerClass, outerClass) + assertSame(encl.name, name) + assertSame(encl.descriptor, descriptor) + } + + def assertNoEnclosingMethod(className: String) = { + assertSame(enclosingMethod(className).outerClass, null) + } + + def printInnerClassNodes(className: String) = { + for (n <- innerClassNodes(className)) { + println(s"${n.name} / ${n.outerName} / ${n.innerName} / ${n.access}") + } + } + + def printEnclosingMethod(className: String) = { + val e = enclosingMethod(className) + println(s"${e.outerClass} / ${e.name} / ${e.descriptor}") + } + + def lambdaClass(anonfunName: String, lambdaName: String): String = { + if (classpath.findClass(anonfunName).isDefined) anonfunName else lambdaName + } + + def testA1() = { + val List(b1) = innerClassNodes("A1") + assertMember(b1, "A1", "B") + val List(b2) = innerClassNodes("A1$B") + assertMember(b2, "A1", "B") + } + + def testA2() = { + val List(b1) = innerClassNodes("A2") + assertMember(b1, "A2", "B$") + val List(b2) = innerClassNodes("A2$B$") + assertMember(b2, "A2", "B$") + } + + def testA3() = { + // the inner class entries for top-level object members are in the companion class, so nothing in the module class + val List() = innerClassNodes("A3$") + + // inner class entries in the companion class (a backend-generated mirror class in this case) + val List(b1, b2) = innerClassNodes("A3") + // the outer class for classes nested inside top-level modules is not the module class, but the mirror class. + // this is a hack for java interop, handled in the backend. see BTypes.scala, comment on "Java Compatibility". + assertMember(b1, "A3", "B1", flags = publicStatic) + assertMember(b2, "A3", "B2$", flags = publicStatic) + } + + def testA4() = { + println("-- A4 --") + printInnerClassNodes("A4") + val fun = lambdaClass("A4$$anonfun$f$1", "A4$lambda$$f$1") + printInnerClassNodes(fun) + printEnclosingMethod(fun) + } + + def testA5() = { + val List(b1) = innerClassNodes("A5") + assertLocal(b1, "A5$B$2$", "B$2$") + val List(b2) = innerClassNodes("A5$B$2$") + assertLocal(b2, "A5$B$2$", "B$2$") + assertEnclosingMethod( + "A5$B$2$", + "A5", "f", "()Ljava/lang/Object;") + } + + def testA6() = { + val List(tt1) = innerClassNodes("A6") + assertMember(tt1, "A6", "TT", flags = publicAbstractInterface) + val List() = innerClassNodes("A6$class") + val List(tt2) = innerClassNodes("A6$TT") + assertMember(tt2, "A6", "TT", flags = publicAbstractInterface) + } + + def testA7() = { + val List() = innerClassNodes("A7") + } + + def testA8() = { + val List(tt) = innerClassNodes("A8") + assertMember(tt, "A6", "TT", flags = publicAbstractInterface) + } + + def testA10() = { + val List() = innerClassNodes("A10") + } + + def testA11() = { + val List(ann) = innerClassNodes("A11") + // in the java class file, the INNERCLASS attribute has more flags (public | static | abstract | interface | annotation) + // the scala compiler has its own interpretation of java annotations ant their flags.. it only emits publicStatic. + assertMember(ann, "JavaAnnot_1", "Ann", flags = publicStatic) + } + + def testA13() = { + val List(b, c) = innerClassNodes("A13") + assertMember(b, "A12", "B$", flags = publicStatic) + assertMember(c, "A12$B$", "C", name = Some("A12$B$C"), flags = publicStatic) + } + + def testA14() = { + val List(anon, k) = innerClassNodes("A14") + + assertLocal(k, "A14$K$1", "K$1") + assertEnclosingMethod( + "A14$K$1", + "A14", "f", "()Ljava/lang/Object;") + + assertAnonymous(anon, "A14$$anon$1") + assertEnclosingMethod( + "A14$$anon$1", + "A14", "g", "()V") + } + + def testA15() = { + // no member classes, only anonymous / local. these are nested in the module class, not the companion. + val List() = innerClassNodes("A15") + + val List(b) = innerClassNodes("A15$") + assertLocal(b, "A15$B$3", "B$3") + + val List(_, c) = innerClassNodes("A15$B$3") + assertMember(c, "A15$B$3", "C") + + assertEnclosingMethod( + "A15$B$3", + "A15$", "f", "()V") + assertNoEnclosingMethod("A15$B$3$C") + } + + def testA16() = { + val List(anon1, anon2, anon3, u, v) = innerClassNodes("A16") + assertAnonymous(anon1, "A16$$anon$2") + assertAnonymous(anon2, "A16$$anon$3") + assertAnonymous(anon3, "A16$$anon$4") + + assertLocal(u, "A16$U$1", "U$1") + assertLocal(v, "A16$V$1", "V$1") + + assertEnclosingMethod( + "A16$$anon$2", + "A16", null, null) + assertEnclosingMethod( + "A16$$anon$3", + "A16", null, null) + assertEnclosingMethod( + "A16$$anon$4", + "A16", null, null) + + assertEnclosingMethod( + "A16$U$1", + "A16", null, null) + assertEnclosingMethod( + "A16$V$1", + "A16", null, null) + } + + def testA17() = { + val List(b, c) = innerClassNodes("A17$B$") + assertMember(b, "A17", "B$") + assertMember(c, "A17$B$", "C", name = Some("A17$B$C")) // not static, has an outer pointer. + } + + def testA18() = { + val List(anon1, anon2, a, b) = innerClassNodes("A18") + assertAnonymous(anon1, "A18$$anon$5") + assertAnonymous(anon2, "A18$$anon$6") + + assertLocal(a, "A18$A$2", "A$2") + assertLocal(b, "A18$B$4", "B$4") + + assertEnclosingMethod( + "A18$$anon$5", + "A18", "g$1", "()V") + assertEnclosingMethod( + "A18$$anon$6", + "A18", "g$1", "()V") + + assertEnclosingMethod( + "A18$A$2", + "A18", "g$1", "()V") + assertEnclosingMethod( + "A18$B$4", + "A18", "g$1", "()V") + } + + def testA19() = { + println("-- A19 --") + + printInnerClassNodes("A19") + + val fun1 = lambdaClass("A19$$anonfun$1", "A19$lambda$1") + val fun2 = lambdaClass("A19$$anonfun$2", "A19$lambda$2") + val fun3 = lambdaClass("A19$$anonfun$3", "A19$lambda$3") + + printInnerClassNodes(fun1) + printInnerClassNodes(fun2) + printInnerClassNodes(fun3) + + printEnclosingMethod(fun1) + printEnclosingMethod(fun2) + printEnclosingMethod(fun3) + } + + def testA20() = { + println("-- A20 --") + + printInnerClassNodes("A20") + + val fun1 = lambdaClass("A20$$anonfun$6", "A20$lambda$1") + val fun2 = lambdaClass("A20$$anonfun$6$$anonfun$apply$1", "A20$lambda$$$nestedInAnonfun$5$1") + val fun3 = lambdaClass("A20$$anonfun$6$$anonfun$apply$3", "A20$lambda$$$nestedInAnonfun$5$2") + val fun4 = lambdaClass("A20$$anonfun$6$$anonfun$apply$3$$anonfun$apply$2", "A20$lambda$$$nestedInAnonfun$7$1") + + println("fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1`") + printInnerClassNodes(fun1) + println("fun2 () => (): itself and the outer closure") + printInnerClassNodes(fun2) + println("fun3 () => () => (): itself, the outer closure and its child closure") + printInnerClassNodes(fun3) + println("fun4: () => 1: itself and the two outer closures") + printInnerClassNodes(fun4) + + println("enclosing: nested closures have outer class defined, but no outer method") + printEnclosingMethod(fun1) + printEnclosingMethod(fun2) + printEnclosingMethod(fun3) + printEnclosingMethod(fun4) + } + + def testA21() = { + val List(i1c, i2c, i3c, j1) = innerClassNodes("A21") + assertMember(i1c, "A21", "I1") + assertMember(i2c, "A21", "I2", flags = publicStatic) + assertMember(i3c, "A21", "I3$", flags = publicStatic) + assertLocal(j1, "A21$J1$1", "J1$1") + + val List(j3, j4, j5) = innerClassNodes("A21$") + assertLocal(j3, "A21$J3$1", "J3$1") + assertLocal(j4, "A21$J4$1", "J4$1") + assertLocal(j5, "A21$J5$1", "J5$1") // non-static! + + val List(i3x, j2x) = innerClassNodes("A21$I3$J2") + assertMember(j2x, "A21$I3$", "J2", name = Some("A21$I3$J2"), flags = publicStatic) + + assertNoEnclosingMethod("A21$I3$J2") + assertEnclosingMethod("A21$J3$1", "A21$", "g", "()V") + assertEnclosingMethod("A21$J4$1", "A21$", null, null) + assertEnclosingMethod("A21$J5$1", "A21$", null, null) + } + + def testA22() = { + val List(cc) = innerClassNodes("A22$C") + assertMember(cc, "A22", "C") + val List(cm, d) = innerClassNodes("A22$C$") + assertMember(cm, "A22", "C$") + assertMember(d, "A22$C$", "D", name = Some("A22$C$D")) + } + + def testA23() { + val List(c, d, e, f, g) = innerClassNodes("A23") + assertMember(c, "Java_A_1", "C", flags = publicStatic) + assertMember(d, "Java_A_1$C", "D", flags = publicStatic) + assertMember(e, "Java_A_1$C", "E") + assertMember(f, "Java_A_1", "F") + assertMember(g, "Java_A_1$F", "G") + } + + def testA24() { + val List(defsCls, abs, conc, defsApi) = innerClassNodes("A24$DefinitionsClass") + assertMember(defsCls, "A24", "DefinitionsClass") + assertMember(abs, "A24$DefinitionsClass", "Abs$") + assertMember(conc, "A24$DefinitionsClass", "Conc$") + assertMember(defsApi, "A24Base", "DefinitionsApi", flags = publicAbstractInterface) + } + + def testSI_9105() { + val isDelambdafyMethod = classpath.findClass("SI_9105$lambda$1").isDefined + if (isDelambdafyMethod) { + assertEnclosingMethod ("SI_9105$A$3" , "SI_9105", null , null) + assertEnclosingMethod ("SI_9105$B$5" , "SI_9105", "m$1", "()Ljava/lang/Object;") + assertEnclosingMethod ("SI_9105$C$1" , "SI_9105", null , null) + assertEnclosingMethod ("SI_9105$D$1" , "SI_9105", "met", "()Lscala/Function0;") + assertEnclosingMethod ("SI_9105$E$1" , "SI_9105", "m$3", "()Ljava/lang/Object;") + assertEnclosingMethod ("SI_9105$F$1" , "SI_9105", "met", "()Lscala/Function0;") + assertNoEnclosingMethod("SI_9105$lambda$$met$1") + assertNoEnclosingMethod("SI_9105$lambda$1") + assertNoEnclosingMethod("SI_9105") + + assertLocal(innerClassNodes("SI_9105$A$3").head, "SI_9105$A$3", "A$3") + assertLocal(innerClassNodes("SI_9105$B$5").head, "SI_9105$B$5", "B$5") + assertLocal(innerClassNodes("SI_9105$C$1").head, "SI_9105$C$1", "C$1") + assertLocal(innerClassNodes("SI_9105$D$1").head, "SI_9105$D$1", "D$1") + assertLocal(innerClassNodes("SI_9105$E$1").head, "SI_9105$E$1", "E$1") + assertLocal(innerClassNodes("SI_9105$F$1").head, "SI_9105$F$1", "F$1") + + // by-name + assertEnclosingMethod("SI_9105$G$1", "SI_9105", null , null) + assertEnclosingMethod("SI_9105$H$1", "SI_9105", "m$2", "()Ljava/lang/Object;") + assertEnclosingMethod("SI_9105$I$1", "SI_9105", null , null) + assertEnclosingMethod("SI_9105$J$1", "SI_9105", "bnM", "()I") + assertEnclosingMethod("SI_9105$K$2", "SI_9105", "m$4", "()Ljava/lang/Object;") + assertEnclosingMethod("SI_9105$L$1", "SI_9105", "bnM", "()I") + + assert(innerClassNodes("SI_9105$lambda$$met$1").isEmpty) + assert(innerClassNodes("SI_9105$lambda$1").isEmpty) + assert(innerClassNodes("SI_9105").length == 12) // the 12 local classes + } else { + // comment in innerClassAttribute/Classes_1.scala explains the difference between A / C and D / F. + assertEnclosingMethod ("SI_9105$$anonfun$4$A$3" , "SI_9105$$anonfun$4" , null , null) + assertEnclosingMethod ("SI_9105$$anonfun$4$B$5" , "SI_9105$$anonfun$4" , "m$1" , "()Ljava/lang/Object;") + assertEnclosingMethod ("SI_9105$$anonfun$4$C$1" , "SI_9105$$anonfun$4" , null , null) + assertEnclosingMethod ("SI_9105$$anonfun$met$1$D$1", "SI_9105$$anonfun$met$1", null , null) + assertEnclosingMethod ("SI_9105$$anonfun$met$1$E$1", "SI_9105$$anonfun$met$1", "m$3" , "()Ljava/lang/Object;") + assertEnclosingMethod ("SI_9105$$anonfun$met$1$F$1", "SI_9105$$anonfun$met$1", null , null) + assertEnclosingMethod ("SI_9105$$anonfun$4" , "SI_9105" , null , null) + assertEnclosingMethod ("SI_9105$$anonfun$met$1" , "SI_9105" , "met" , "()Lscala/Function0;") + assertNoEnclosingMethod("SI_9105") + + assertLocal(ownInnerClassNode("SI_9105$$anonfun$4$A$3"), "SI_9105$$anonfun$4$A$3" , "A$3") + assertLocal(ownInnerClassNode("SI_9105$$anonfun$4$B$5"), "SI_9105$$anonfun$4$B$5" , "B$5") + assertLocal(ownInnerClassNode("SI_9105$$anonfun$4$C$1"), "SI_9105$$anonfun$4$C$1" , "C$1") + assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$D$1"), "SI_9105$$anonfun$met$1$D$1", "D$1") + assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$E$1"), "SI_9105$$anonfun$met$1$E$1", "E$1") + assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$F$1"), "SI_9105$$anonfun$met$1$F$1", "F$1") + + // by-name + assertEnclosingMethod("SI_9105$$anonfun$5$G$1", "SI_9105$$anonfun$5", null, null) + assertEnclosingMethod("SI_9105$$anonfun$5$H$1", "SI_9105$$anonfun$5", "m$2", "()Ljava/lang/Object;") + assertEnclosingMethod("SI_9105$$anonfun$5$I$1", "SI_9105$$anonfun$5", null, null) + assertEnclosingMethod("SI_9105$$anonfun$bnM$1$J$1", "SI_9105$$anonfun$bnM$1", null, null) + assertEnclosingMethod("SI_9105$$anonfun$bnM$1$K$2", "SI_9105$$anonfun$bnM$1", "m$4", "()Ljava/lang/Object;") + assertEnclosingMethod("SI_9105$$anonfun$bnM$1$L$1", "SI_9105$$anonfun$bnM$1", null, null) + + assertAnonymous(ownInnerClassNode("SI_9105$$anonfun$4"), "SI_9105$$anonfun$4") + assertAnonymous(ownInnerClassNode("SI_9105$$anonfun$met$1"), "SI_9105$$anonfun$met$1") + + assert(innerClassNodes("SI_9105$$anonfun$4").length == 4) // itself and three of the local classes + assert(innerClassNodes("SI_9105$$anonfun$met$1").length == 4) // itself and three of the local classes + assert(innerClassNodes("SI_9105").length == 4) // the four anon funs + } + } + + def testSI_9124() { + val classes: Map[String, String] = { + List("SI_9124$$anon$10", + "SI_9124$$anon$11", + "SI_9124$$anon$12", + "SI_9124$$anon$8", + "SI_9124$$anon$9", + "SI_9124$O$$anon$13").map({ name => + val node = loadClassNode(name) + val fMethod = node.methods.asScala.find(_.name.startsWith("f")).get.name + (fMethod, node.name) + }).toMap + } + + // println(classes) + + assertNoEnclosingMethod("SI_9124$A") + assertEnclosingMethod(classes("f1"), "SI_9124", null, null) + assertEnclosingMethod(classes("f2"), "SI_9124", "f", "()LSI_9124$A;") + assertEnclosingMethod(classes("f3"), "SI_9124", null, null) + assertEnclosingMethod(classes("f4"), "SI_9124$O$", null, null) + assertEnclosingMethod(classes("f5"), "SI_9124", null, null) + assertEnclosingMethod(classes("f6"), "SI_9124", null, null) + assertNoEnclosingMethod("SI_9124$O$") + + assertMember(ownInnerClassNode("SI_9124$A"), "SI_9124", "A", flags = publicAbstractInterface) + classes.values.foreach(n => assertAnonymous(ownInnerClassNode(n), n)) + assertMember(ownInnerClassNode("SI_9124$O$"), "SI_9124", "O$") + } + + def testImplClassesTopLevel() { + val classes = List( + "ImplClassesAreTopLevel$$anon$14", + "ImplClassesAreTopLevel$$anon$15", + "ImplClassesAreTopLevel$$anon$16", + "ImplClassesAreTopLevel$B1$class", + "ImplClassesAreTopLevel$B1", + "ImplClassesAreTopLevel$B2$1$class", + "ImplClassesAreTopLevel$B2$1", + "ImplClassesAreTopLevel$B3$1$class", + "ImplClassesAreTopLevel$B3$1", + "ImplClassesAreTopLevel$B4$class", + "ImplClassesAreTopLevel$B4$1", + "ImplClassesAreTopLevel$class", + "ImplClassesAreTopLevel") + + classes.filter(_.endsWith("$class")).foreach(assertNoEnclosingMethod) + classes.flatMap(innerClassNodes).foreach(icn => assert(!icn.name.endsWith("$class"), icn)) + + assertNoEnclosingMethod("ImplClassesAreTopLevel$B1") // member, no encl meth attr + + // no encl meth, but encl class + List("ImplClassesAreTopLevel$B2$1", "ImplClassesAreTopLevel$B3$1", + "ImplClassesAreTopLevel$$anon$14", "ImplClassesAreTopLevel$$anon$15").foreach(assertEnclosingMethod(_, "ImplClassesAreTopLevel", null, null)) + + // encl meth n + List("ImplClassesAreTopLevel$B4$1", "ImplClassesAreTopLevel$$anon$16").foreach(assertEnclosingMethod(_, "ImplClassesAreTopLevel", "n", "()Ljava/lang/Object;")) + + val an14 = assertAnonymous(_: InnerClassNode, "ImplClassesAreTopLevel$$anon$14") + val an15 = assertAnonymous(_: InnerClassNode, "ImplClassesAreTopLevel$$anon$15") + val an16 = assertAnonymous(_: InnerClassNode, "ImplClassesAreTopLevel$$anon$16") + val b1 = assertMember(_: InnerClassNode, "ImplClassesAreTopLevel", "B1", flags = publicAbstractInterface) + val b2 = assertLocal(_ : InnerClassNode, "ImplClassesAreTopLevel$B2$1", "B2$1", flags = publicAbstractInterface) + val b3 = assertLocal(_ : InnerClassNode, "ImplClassesAreTopLevel$B3$1", "B3$1", flags = publicAbstractInterface) + val b4 = assertLocal(_ : InnerClassNode, "ImplClassesAreTopLevel$B4$1", "B4$1", flags = publicAbstractInterface) + + testInner("ImplClassesAreTopLevel$$anon$14", an14, b3) + testInner("ImplClassesAreTopLevel$$anon$15", an15, b2) + testInner("ImplClassesAreTopLevel$$anon$16", an16, b4) + + testInner("ImplClassesAreTopLevel$B1$class", b1) + testInner("ImplClassesAreTopLevel$B2$1$class", b2) + testInner("ImplClassesAreTopLevel$B3$1$class", b3) + testInner("ImplClassesAreTopLevel$B4$class", b4) + + testInner("ImplClassesAreTopLevel$B1", b1) + testInner("ImplClassesAreTopLevel$B2$1", b2) + testInner("ImplClassesAreTopLevel$B3$1", b3) + testInner("ImplClassesAreTopLevel$B4$1", b4) + + testInner("ImplClassesAreTopLevel$class", an14, an15, an16) + testInner("ImplClassesAreTopLevel", an14, an15, an16, b1, b2, b3, b4) + } + + def testSpecializedClassesTopLevel() { + val cls = List( + "SpecializedClassesAreTopLevel$A$mcI$sp", + "SpecializedClassesAreTopLevel$A", + "SpecializedClassesAreTopLevel$T$", + "SpecializedClassesAreTopLevel$T$B$mcI$sp", + "SpecializedClassesAreTopLevel$T$B", + "SpecializedClassesAreTopLevel") + + // all classes are members, no local (can't test local, they crash in specialize) + cls.foreach(assertNoEnclosingMethod) + cls.flatMap(innerClassNodes).foreach(icn => assert(!icn.name.endsWith("$sp"), icn)) + + val a = assertMember(_: InnerClassNode, "SpecializedClassesAreTopLevel", "A") + val t = assertMember(_: InnerClassNode, "SpecializedClassesAreTopLevel", "T$") + val b = assertMember(_: InnerClassNode, "SpecializedClassesAreTopLevel$T$", "B", Some("SpecializedClassesAreTopLevel$T$B")) + + List("SpecializedClassesAreTopLevel$A$mcI$sp", "SpecializedClassesAreTopLevel$A").foreach(testInner(_, a)) + testInner("SpecializedClassesAreTopLevel", a, t) + List("SpecializedClassesAreTopLevel$T$", "SpecializedClassesAreTopLevel$T$B$mcI$sp", "SpecializedClassesAreTopLevel$T$B").foreach(testInner(_, t, b)) + } + + def testNestedInValueClass() { + List( + "NestedInValueClass", + "NestedInValueClass$", + "NestedInValueClass$A", + "NestedInValueClass$A$", + "NestedInValueClass$A$B").foreach(assertNoEnclosingMethod) + + assertEnclosingMethod("NestedInValueClass$A$C$2", "NestedInValueClass$A$", "f", "()Ljava/lang/Object;") + + type I = InnerClassNode + val a = assertMember(_: I, "NestedInValueClass", "A", flags = publicStatic | Flags.ACC_FINAL) + val am = assertMember(_: I, "NestedInValueClass", "A$", flags = publicStatic) + val b = assertMember(_: I, "NestedInValueClass$A$", "B", Some("NestedInValueClass$A$B"), flags = publicStatic) + val c = assertLocal(_: I, "NestedInValueClass$A$C$2", "C$2") + + testInner("NestedInValueClass$") + testInner("NestedInValueClass", a, am) + testInner("NestedInValueClass$A$B", am, b) + testInner("NestedInValueClass$A$C$2", am, c) + + val isDelambdafyMethod = classpath.findClass("NestedInValueClass$A$lambda$$f$extension$1").isDefined + if (isDelambdafyMethod) { + List( + "NestedInValueClass$A$lambda$$g$2$1", + "NestedInValueClass$A$lambda$$f$extension$1", + "NestedInValueClass$A$lambda$$$nestedInAnonfun$13$1", + "NestedInValueClass$A$lambda$$$nestedInAnonfun$15$1").foreach(assertNoEnclosingMethod) + testInner("NestedInValueClass$A", a, am) + testInner("NestedInValueClass$A$", a, am, b, c) + testInner("NestedInValueClass$A$lambda$$g$2$1", am) + testInner("NestedInValueClass$A$lambda$$f$extension$1", am) + testInner("NestedInValueClass$A$lambda$$$nestedInAnonfun$13$1", am) + testInner("NestedInValueClass$A$lambda$$$nestedInAnonfun$15$1", am) + } else { + assertEnclosingMethod("NestedInValueClass$A$$anonfun$g$2$1" , "NestedInValueClass$A" , null, null) + assertEnclosingMethod("NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4" , "NestedInValueClass$A$$anonfun$g$2$1" , null, null) + assertEnclosingMethod("NestedInValueClass$A$$anonfun$f$extension$1" , "NestedInValueClass$A" , "f", "()Lscala/collection/immutable/List;") + assertEnclosingMethod("NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5", "NestedInValueClass$A$$anonfun$f$extension$1", null, null) + + val gfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$g$2$1") + val ffun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$f$extension$1") + val gfunfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4") + val ffunfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5") + + testInner("NestedInValueClass$A", a, am, ffun, gfun) + testInner("NestedInValueClass$A$", a, am, ffun, gfun, b, c) + testInner("NestedInValueClass$A$$anonfun$g$2$1", a, am, gfun, gfunfun) + testInner("NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4", am, gfun, gfunfun) + testInner("NestedInValueClass$A$$anonfun$f$extension$1", a, am, ffun, ffunfun) + testInner("NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5", am, ffun, ffunfun) + } + } + + def show(): Unit = { + testA1() + testA2() + testA3() + testA4() + testA5() + testA6() + testA7() + testA8() + testA10() + testA11() + testA13() + testA14() + testA15() + testA16() + testA17() + testA18() + testA19() + testA20() + testA21() + testA22() + testA23() + testA24() + testSI_9105() + testSI_9124() + testImplClassesTopLevel() + testSpecializedClassesTopLevel() + testNestedInValueClass() + } +} diff --git a/test/files/jvm/innerClassEnclMethodJavaReflection.scala b/test/files/jvm/innerClassEnclMethodJavaReflection.scala new file mode 100644 index 0000000000..ee39cb43bf --- /dev/null +++ b/test/files/jvm/innerClassEnclMethodJavaReflection.scala @@ -0,0 +1,65 @@ +import scala.reflect.io._ +import java.net.URLClassLoader + +object Test extends App { + val jarsOrDirectories = Set("partest.lib", "partest.reflect", "partest.comp") map sys.props + + object AllowedMissingClass { + // Some classes in scala-compiler.jar have references to jline / ant classes, which seem to be + // not on the classpath. We just skip over those classes. + // PENDING: for now we also allow missing $anonfun classes: the optimizer may eliminate some closures + // that are refferred to in EnclosingClass attributes. SI-9136 + val allowedMissingPackages = Set("jline", "org.apache.tools.ant", "$anonfun") + + def ok(t: Throwable) = { + allowedMissingPackages.exists(p => t.getMessage.replace('/', '.').contains(p)) + } + + def unapply(t: Throwable): Option[Throwable] = t match { + case _: NoClassDefFoundError | _: ClassNotFoundException | _: TypeNotPresentException if ok(t) => Some(t) + case _ => None + } + } + + jarsOrDirectories foreach testClasses + + def testClasses(jarOrDirectory: String): Unit = { + val classPath = AbstractFile.getDirectory(new java.io.File(jarOrDirectory)) + + def flatten(f: AbstractFile): Iterator[AbstractFile] = + if (f.isClassContainer) f.iterator.flatMap(flatten) + else Iterator(f) + + val classFullNames = flatten(classPath).filter(_.hasExtension("class")).map(_.path.replace("/", ".").replaceAll(".class$", "")) + + // it seems that Class objects can only be GC'd together with their class loader + // (http://stackoverflow.com/questions/2433261/when-and-how-are-classes-garbage-collected-in-java) + // if we just use the same class loader for the entire test (Class.forName), we run out of PermGen + // even with that, we still neeed a PermGen of 90M or so, the default 64 is not enough. I tried + // using one class loader per 100 classes, but that didn't help, the classes didn't get GC'd. + val classLoader = new URLClassLoader(Array(classPath.toURL)) + + val faulty = new collection.mutable.ListBuffer[(String, Throwable)] + + def tryGetClass(name: String) = try { + Some[Class[_]](classLoader.loadClass(name)) + } catch { + case AllowedMissingClass(_) => None + } + + for (name <- classFullNames; cls <- tryGetClass(name)) { + try { + cls.getEnclosingMethod + cls.getEnclosingClass + cls.getEnclosingConstructor + cls.getDeclaredClasses + } catch { + case AllowedMissingClass(_) => + case t: Throwable => faulty += ((name, t)) + } + } + + if (faulty.nonEmpty) + println(faulty.toList mkString "\n") + } +} diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check index b55ecc10e6..d03edb638c 100644 --- a/test/files/jvm/interpreter.check +++ b/test/files/jvm/interpreter.check @@ -95,7 +95,7 @@ scala> case class Bar(n: Int) defined class Bar scala> implicit def foo2bar(foo: Foo) = Bar(foo.n) -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details foo2bar: (foo: Foo)Bar scala> val bar: Bar = Foo(3) @@ -269,7 +269,7 @@ scala> xs map (x => x) res6: Array[_] = Array(1, 2) scala> xs map (x => (x, x)) -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details res7: Array[(_$1, _$1)] forSome { type _$1 } = Array((1,1), (2,2)) scala> @@ -361,7 +361,7 @@ It would fail on the following inputs: Exp(), Term() ^ f: (e: Exp)Int -scala> +scala> :quit plusOne: (x: Int)Int res0: Int = 6 res0: String = after reset diff --git a/test/files/jvm/javaReflection.check b/test/files/jvm/javaReflection.check new file mode 100644 index 0000000000..8180ecff8a --- /dev/null +++ b/test/files/jvm/javaReflection.check @@ -0,0 +1,259 @@ +#partest !-Ydelambdafy:method +A$$anonfun$$lessinit$greater$1 / null (canon) / $anonfun$$lessinit$greater$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$$lessinit$greater$1$$anonfun$apply$1 / null (canon) / $anonfun$apply$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$$anonfun$$lessinit$greater$1 (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$2 / null (canon) / $anonfun$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$3 / null (canon) / $anonfun$3 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$4 / null (canon) / $anonfun$4 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$f$1 / null (canon) / $anonfun$f$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$$anonfun$f$2 / null (canon) / $anonfun$f$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$D$$anonfun$1 / null (canon) / anonfun$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AO$$anonfun$5 / null (canon) / anonfun$5 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class AO$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AT$$anonfun$6 / null (canon) / $anonfun$6 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +#partest -Ydelambdafy:method +A$D$lambda$1 / A$D$lambda$1 (canon) / A$D$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$$lessinit$greater$1 / A$lambda$$$lessinit$greater$1 (canon) / A$lambda$$$lessinit$greater$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$$nestedInAnonfun$7$1 / A$lambda$$$nestedInAnonfun$7$1 (canon) / A$lambda$$$nestedInAnonfun$7$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$f$1 / A$lambda$$f$1 (canon) / A$lambda$$f$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$f$2 / A$lambda$$f$2 (canon) / A$lambda$$f$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$1 / A$lambda$1 (canon) / A$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$2 / A$lambda$2 (canon) / A$lambda$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$3 / A$lambda$3 (canon) / A$lambda$3 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AO$lambda$1 / AO$lambda$1 (canon) / AO$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AT$class$lambda$1 / AT$class$lambda$1 (canon) / AT$class$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +#partest +A / A (canon) / A (simple) +- declared cls: List(class A$B, interface A$C, class A$D$) +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$$anon$1 / null (canon) / $anon$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anon$3 / null (canon) / $anon$3 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anon$4 / null (canon) / $anon$4 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$$anon$5 / null (canon) / $anon$5 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$$anon$6 / null (canon) / $anon$6 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anon$7 / null (canon) / $anon$7 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$B / A.B (canon) / B (simple) +- declared cls: List() +- enclosing : class A (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$C / A.C (canon) / C (simple) +- declared cls: List() +- enclosing : class A (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$ / A.D$ (canon) / D$ (simple) +- declared cls: List(class A$D$B, interface A$D$C, class A$D$D$) +- enclosing : class A (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$$anon$2 / null (canon) / anon$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$D$B / Malformed class name (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : class A$D$ (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$C / Malformed class name (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : class A$D$ (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$D$ / Malformed class name (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : class A$D$ (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$KB$1 / null (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$D$ (cls) / null (constr) / public void A$D$.f() (meth) +- properties : Malformed class name (local) / false (member) +A$E$1 / null (canon) / E$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$F$1 / null (canon) / F$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$G$2$ / null (canon) / G$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$H$1 / null (canon) / H$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$I$1 / null (canon) / I$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$J$2$ / null (canon) / J$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$K$1 / null (canon) / K$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$L$1 / null (canon) / L$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$M$2$ / null (canon) / M$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$N$1 / null (canon) / N$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$O$1 / null (canon) / O$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$P$2$ / null (canon) / P$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$Q$1 / null (canon) / Q$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$R$1 / null (canon) / R$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$S$2$ / null (canon) / S$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +AO / AO (canon) / AO (simple) +- declared cls: List(class AO$B, interface AO$C, class AO$D$) +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AO$ / AO$ (canon) / AO$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AO$$anon$8 / null (canon) / anon$8 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class AO$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AO$B / AO.B (canon) / B (simple) +- declared cls: List() +- enclosing : class AO (declaring cls) / class AO (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AO$C / AO.C (canon) / C (simple) +- declared cls: List() +- enclosing : class AO (declaring cls) / class AO (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AO$D$ / AO.D$ (canon) / D$ (simple) +- declared cls: List() +- enclosing : class AO (declaring cls) / class AO (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT / AT (canon) / AT (simple) +- declared cls: List(class AT$B, interface AT$C, class AT$D$) +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AT$$anon$9 / null (canon) / $anon$9 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AT$B / AT.B (canon) / B (simple) +- declared cls: List() +- enclosing : interface AT (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT$C / AT.C (canon) / C (simple) +- declared cls: List() +- enclosing : interface AT (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT$D$ / AT.D$ (canon) / D$ (simple) +- declared cls: List() +- enclosing : interface AT (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT$class / AT$class (canon) / AT$class (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +T / T (canon) / T (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +T$class / T$class (canon) / T$class (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) diff --git a/test/files/jvm/javaReflection/Classes_1.scala b/test/files/jvm/javaReflection/Classes_1.scala new file mode 100644 index 0000000000..11963e2770 --- /dev/null +++ b/test/files/jvm/javaReflection/Classes_1.scala @@ -0,0 +1,84 @@ +// See Test.scala for comments + +trait T { def f = 1 } + +class A { + // member class + class B + // member trait + trait C + // member object + object D { + class B + trait C + object D + new T { } + (() => -1) + def f = { class KB } + } + + // anonymous class, not a member + new T { } + + // anonymous function, not a member + (() => 1) + + def f = { + class E + trait F + object G + new T { } + (() => 2) + + if (new Object().hashCode == 1) { + class H + trait I + object J + new T { } + (() => 3) + } else { + () + } + } + + { + class K + trait L + object M + new T { } + (() => 4) + } + + val x = { + class N + trait O + object P + new T { } + (() => 5) + } + + def this(x: Int) { + this() + class Q + trait R + object S + new T { } + (() => () => 5) + } +} + +object AO { + class B + trait C + object D + new T { } + (() => 1) +} + +trait AT { + class B + trait C + object D + new T { } + (() => 1) +} diff --git a/test/files/jvm/javaReflection/Test.scala b/test/files/jvm/javaReflection/Test.scala new file mode 100644 index 0000000000..ae5a36eeb2 --- /dev/null +++ b/test/files/jvm/javaReflection/Test.scala @@ -0,0 +1,137 @@ +/** +Interesting aspects of Java reflection applied to scala classes. TL;DR: you should not use +getSimpleName / getCanonicalName / isAnonymousClass / isLocalClass / isSynthetic. + + - Some methods in Java reflection assume a certain structure in the class names. Scalac + can produce class files that don't respect this structure. Certain methods in reflection + therefore give surprising answers or may even throw an exception. + + In particular, the method "getSimpleName" assumes that classes are named after the Java spec + http://docs.oracle.com/javase/specs/jls/se8/html/jls-13.html#jls-13.1 + + Consider the following Scala example: + class A { object B { class C } } + + The classfile for C has the name "A$B$C", while the classfile for the module B has the + name "A$B$". + + For "cClass.getSimpleName, the implementation first strips the name of the enclosing class, + which produces "C". The implementation then expects a "$" character, which is missing, and + throws an InternalError. + + Consider another example: + trait T + class A { val x = new T {} } + object B { val x = new T {} } + + The anonymous classes are named "A$$anon$1" and "B$$anon$2". If you call "getSimpleName", + you get "$anon$1" (leading $) and "anon$2" (no leading $). + + - There are certain other methods in the Java reflection API that depend on getSimpleName. + These should be avoided, they yield unexpected results: + + - isAnonymousClass is always false. Scala-defined classes are never anonymous for Java + reflection. Java reflection insepects the class name to decide whether a class is + anonymous, based on the name spec referenced above. + Also, the implementation of "isAnonymousClass" calls "getSimpleName", which may throw. + + - isLocalClass: should be true true for local classes (nested classes that are not + members), but not for anonymous classes. Since "isAnonymousClass" is always false, + Java reflection thinks that all Scala-defined anonymous classes are local. + The implementation may also throw, since it uses "isAnonymousClass": + class A { object B { def f = { class KB; new KB } } } + (new A).B.f.getClass.isLocalClass // boom + + - getCanonicalName: uses "getSimpleName" in the implementation. In the first example, + cClass.getCanonicalName also fails with an InternalError. + + - Scala-defined classes are never synthetic for Java reflection. The implementation + checks for the SYNTHETEIC flag, which does not seem to be added by scalac (maybe this + will change some day). +*/ + +object Test { + + def tr[T](m: => T): String = try { + val r = m + if (r == null) "null" + else r.toString + } catch { case e: InternalError => e.getMessage } + + def assertNotAnonymous(c: Class[_]) = { + val an = try { + c.isAnonymousClass + } catch { + // isAnonymousClass is implemented using getSimpleName, which may throw. + case e: InternalError => false + } + assert(!an, c) + } + + def ruleMemberOrLocal(c: Class[_]) = { + // if it throws, then it's because of the call from isLocalClass to isAnonymousClass. + // we know that isAnonymousClass is always false, so it has to be a local class. + val loc = try { c.isLocalClass } catch { case e: InternalError => true } + if (loc) + assert(!c.isMemberClass, c) + if (c.isMemberClass) + assert(!loc, c) + } + + def ruleMemberDeclaring(c: Class[_]) = { + if (c.isMemberClass) + assert(c.getDeclaringClass.getDeclaredClasses.toList.map(_.getName) contains c.getName) + } + + def ruleScalaAnonClassIsLocal(c: Class[_]) = { + if (c.getName contains "$anon$") + assert(c.isLocalClass, c) + } + + def ruleScalaAnonFunInlineIsLocal(c: Class[_]) = { + // exclude lambda classes generated by delambdafy:method. nested closures have both "anonfun" and "lambda". + if (c.getName.contains("$anonfun$") && !c.getName.contains("$lambda$")) + assert(c.isLocalClass, c) + } + + def ruleScalaAnonFunMethodIsToplevel(c: Class[_]) = { + if (c.getName.contains("$lambda$")) + assert(c.getEnclosingClass == null, c) + } + + def showClass(name: String) = { + val c = Class.forName(name) + + println(s"${c.getName} / ${tr(c.getCanonicalName)} (canon) / ${tr(c.getSimpleName)} (simple)") + println( "- declared cls: "+ c.getDeclaredClasses.toList.sortBy(_.getName)) + println(s"- enclosing : ${c.getDeclaringClass} (declaring cls) / ${c.getEnclosingClass} (cls) / ${c.getEnclosingConstructor} (constr) / ${c.getEnclosingMethod} (meth)") + println(s"- properties : ${tr(c.isLocalClass)} (local) / ${c.isMemberClass} (member)") + + assertNotAnonymous(c) + assert(!c.isSynthetic, c) + + ruleMemberOrLocal(c) + ruleMemberDeclaring(c) + ruleScalaAnonClassIsLocal(c) + ruleScalaAnonFunInlineIsLocal(c) + ruleScalaAnonFunMethodIsToplevel(c) + } + + def main(args: Array[String]): Unit = { + def isAnonFunClassName(s: String) = s.contains("$anonfun$") || s.contains("$lambda$") + + val classfiles = new java.io.File(sys.props("partest.output")).listFiles().toList.map(_.getName).collect({ + // exclude files from Test.scala, just take those from Classes_1.scala + case s if !s.startsWith("Test") && s.endsWith(".class") => s.substring(0, s.length - 6) + }).sortWith((a, b) => { + // sort such that first there are all anonymous functions, then all other classes. + // within those categories, sort lexically. + // this makes the check file smaller: it differs for anonymous functions between -Ydelambdafy:inline/method. + // the other classes are the same. + if (isAnonFunClassName(a)) !isAnonFunClassName(b) || a < b + else !isAnonFunClassName(b) && a < b + }) + + classfiles foreach showClass + } +}
\ No newline at end of file diff --git a/test/files/jvm/serialization-new.check b/test/files/jvm/serialization-new.check index 47d7bfd920..cb26446f40 100644 --- a/test/files/jvm/serialization-new.check +++ b/test/files/jvm/serialization-new.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were three deprecation warnings; re-run with -deprecation for details a1 = Array[1,2,3] _a1 = Array[1,2,3] arrayEquals(a1, _a1): true diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization.check index 47d7bfd920..cb26446f40 100644 --- a/test/files/jvm/serialization.check +++ b/test/files/jvm/serialization.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were three deprecation warnings; re-run with -deprecation for details a1 = Array[1,2,3] _a1 = Array[1,2,3] arrayEquals(a1, _a1): true diff --git a/test/files/jvm/t6941/test.scala b/test/files/jvm/t6941/test.scala index 248617f71f..fceb54487f 100644 --- a/test/files/jvm/t6941/test.scala +++ b/test/files/jvm/t6941/test.scala @@ -1,4 +1,4 @@ -import scala.tools.partest.BytecodeTest +import scala.tools.partest.{BytecodeTest, ASMConverters} import scala.tools.nsc.util.JavaClassPath import java.io.InputStream @@ -10,6 +10,6 @@ import scala.collection.JavaConverters._ object Test extends BytecodeTest { def show: Unit = { val classNode = loadClassNode("SameBytecode") - similarBytecode(getMethod(classNode, "a"), getMethod(classNode, "b"), equalsModuloVar) + similarBytecode(getMethod(classNode, "a"), getMethod(classNode, "b"), ASMConverters.equivalentBytecode(_, _)) } } diff --git a/test/files/jvm/t7253/test.scala b/test/files/jvm/t7253/test.scala index 7fe08e8813..a3f1e86e65 100644 --- a/test/files/jvm/t7253/test.scala +++ b/test/files/jvm/t7253/test.scala @@ -1,4 +1,4 @@ -import scala.tools.partest.BytecodeTest +import scala.tools.partest.{BytecodeTest, ASMConverters} import scala.tools.nsc.util.JavaClassPath import java.io.InputStream @@ -8,10 +8,10 @@ import asm.tree.{ClassNode, InsnList} import scala.collection.JavaConverters._ object Test extends BytecodeTest { - import instructions._ + import ASMConverters._ def show: Unit = { - val instrBaseSeqs = Seq("ScalaClient_1", "JavaClient_1") map (name => instructions.fromMethod(getMethod(loadClassNode(name), "foo"))) + val instrBaseSeqs = Seq("ScalaClient_1", "JavaClient_1") map (name => instructionsFromMethod(getMethod(loadClassNode(name), "foo"))) val instrSeqs = instrBaseSeqs map (_ filter isInvoke) cmpInstructions(instrSeqs(0), instrSeqs(1)) } diff --git a/test/files/jvm/t8582.check b/test/files/jvm/t8582.check new file mode 100644 index 0000000000..e388366270 --- /dev/null +++ b/test/files/jvm/t8582.check @@ -0,0 +1,44 @@ +getClass on module gives module class + class p1.p2.Singleton$Singleton$ + +Nested module classes are found through reflection + p1.p2.Singleton$Singleton$: List(class p1.p2.Singleton$Singleton$Singleton$) + +Reflection can find direct nested classes (A1-B1-C1) + A1: List(class A1$B1) + A1$B1: List(class A1$B1$C1) + A1$B1$C1: List() + +Reflection can find direct nested classes (A2-B2-C2) + A2: List(class A2$B2) + A2$B2: List(class A2$B2$C2) + A2$B2$C2: List() + +The InnerClass attribute of a mirror class contains the members of the module class: + className[p1/p2/Singleton$Singleton$] outerClassName[p1/p2/Singleton] innerName[Singleton$] access[9] +The module members are not in the InnerClass table of the module class (unless referenced): + + +An outer class has a InnerClass attribute for direct nested classes + className[A1$B1] outerClassName[A1] innerName[B1] access[1] +A nested class has an InnerClass attribute for itself (and also for its nested classes) + className[A1$B1] outerClassName[A1] innerName[B1] access[1] + className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1] +C1 is a nested class, so it has an InnerClass attribute for itself. +Because that attribute leads to an entry for B1 in the constant pool, C1 needs an InnerClass attribute for B1. + className[A1$B1] outerClassName[A1] innerName[B1] access[1] + className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1] + +The BeanInfo class has the same InnerClass attributes as the corresponding bean + className[A1$B1] outerClassName[A1] innerName[B1] access[1] + className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1] + +Class A2 mentions class C2 in the constant pool (due to method f), therefore it needs an InnerClass attribute for C1 + className[A2$B2] outerClassName[A2] innerName[B2] access[1] + className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1] +B2 + className[A2$B2] outerClassName[A2] innerName[B2] access[1] + className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1] +C2 + className[A2$B2] outerClassName[A2] innerName[B2] access[1] + className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1] diff --git a/test/files/jvm/t8582.scala b/test/files/jvm/t8582.scala new file mode 100644 index 0000000000..e9a01f9016 --- /dev/null +++ b/test/files/jvm/t8582.scala @@ -0,0 +1,81 @@ +import scala.tools.partest.BytecodeTest +import scala.collection.JavaConverters._ + +package p1 { + package p2 { + object Singleton { + object Singleton { + object Singleton + } + } + } +} + +class A1 { + class B1 { + @scala.beans.BeanInfo + class C1 + } +} + +class A2 { + class B2 { + class C2 + } + def f: B2#C2 = null +} + + +object Test extends BytecodeTest { + import p1.p2._ + + def nested(c: Class[_]) = s" ${c.getName}: ${c.getDeclaredClasses.toList}" + + def nprintln(s: String) = println("\n"+s) + def printInner(cname: String): Unit = { + val cnode = loadClassNode(cname) + println(cnode.innerClasses.asScala.toList.map(i => s"className[${i.name}] outerClassName[${i.outerName}] innerName[${i.innerName}] access[${i.access}]").mkString(" ", "\n ", "")) + } + + def show() { + + println("getClass on module gives module class") + println(" " + Singleton.Singleton.getClass) + + nprintln("Nested module classes are found through reflection") + println(nested(Singleton.Singleton.getClass)) + + nprintln("Reflection can find direct nested classes (A1-B1-C1)") + println(nested(classOf[A1])) + println(nested(classOf[A1#B1])) + println(nested(classOf[A1#B1#C1])) + + nprintln("Reflection can find direct nested classes (A2-B2-C2)") + println(nested(classOf[A2])) + println(nested(classOf[A2#B2])) + println(nested(classOf[A2#B2#C2])) + + nprintln("The InnerClass attribute of a mirror class contains the members of the module class:") + printInner("p1.p2.Singleton") // mirror class + println("The module members are not in the InnerClass table of the module class (unless referenced):") + printInner("p1.p2.Singleton$") + + nprintln("An outer class has a InnerClass attribute for direct nested classes") + printInner("A1") + println("A nested class has an InnerClass attribute for itself (and also for its nested classes)") + printInner("A1$B1") + println("C1 is a nested class, so it has an InnerClass attribute for itself.\n"+ + "Because that attribute leads to an entry for B1 in the constant pool, C1 needs an InnerClass attribute for B1.") + printInner("A1$B1$C1") + + nprintln("The BeanInfo class has the same InnerClass attributes as the corresponding bean") + printInner("A1$B1$C1BeanInfo") + + nprintln("Class A2 mentions class C2 in the constant pool (due to method f), therefore it needs an InnerClass attribute for C1") + printInner("A2") + println("B2") + printInner("A2$B2") + println("C2") + printInner("A2$B2$C2") + } +} diff --git a/test/files/jvm/t8689.check b/test/files/jvm/t8689.check new file mode 100644 index 0000000000..2e9ba477f8 --- /dev/null +++ b/test/files/jvm/t8689.check @@ -0,0 +1 @@ +success diff --git a/test/files/jvm/t8689.scala b/test/files/jvm/t8689.scala new file mode 100644 index 0000000000..3ee20d711a --- /dev/null +++ b/test/files/jvm/t8689.scala @@ -0,0 +1,18 @@ +object Test { + def main(args: Array[String]): Unit = { + import scala.concurrent._ + import ExecutionContext.Implicits.global + val source1 = Promise[Int]() + val source2 = Promise[Int]() + val done = Promise[Unit]() + source2.completeWith(source1.future).future.onComplete { + case _ => + print("success") + done.success(()) + } + source2.tryFailure(new TimeoutException) + source1.success(123) + import duration._ + Await.result(done.future, 120.seconds) + } +} diff --git a/test/files/jvm/t9044.scala b/test/files/jvm/t9044.scala new file mode 100644 index 0000000000..b1073325e8 --- /dev/null +++ b/test/files/jvm/t9044.scala @@ -0,0 +1,6 @@ +trait A +trait B +object Test extends A with B with App { + val is = Test.getClass.getInterfaces.mkString(", ") + assert(is == "interface A, interface B, interface scala.App", is) +} diff --git a/test/files/jvm/t9105.check b/test/files/jvm/t9105.check new file mode 100644 index 0000000000..34750833f1 --- /dev/null +++ b/test/files/jvm/t9105.check @@ -0,0 +1,18 @@ +#partest !-Ydelambdafy:method +(class C$$anonfun$1$A$1,class C$$anonfun$1,null) +(class C$$anonfun$1$B$1,class C$$anonfun$1,private final java.lang.Object C$$anonfun$1.m$1()) +(class C$$anonfun$1$C$1,class C$$anonfun$1,null) +(class C$$anonfun$1$$anonfun$2$D$1,class C$$anonfun$1$$anonfun$2,null) +(class C$$anonfun$met$1$E$1,class C$$anonfun$met$1,null) +(class C$$anonfun$met$1$F$1,class C$$anonfun$met$1,private final java.lang.Object C$$anonfun$met$1.m$2()) +(class C$$anonfun$met$1$G$1,class C$$anonfun$met$1,null) +(class C$$anonfun$met$1$$anonfun$3$H$1,class C$$anonfun$met$1$$anonfun$3,null) +#partest -Ydelambdafy:method +(class C$A$1,class C,null) +(class C$B$1,class C,private final java.lang.Object C.m$1()) +(class C$C$1,class C,null) +(class C$D$1,class C,null) +(class C$E$1,class C,public scala.Function0 C.met()) +(class C$F$1,class C,private final java.lang.Object C.m$2()) +(class C$G$1,class C,public scala.Function0 C.met()) +(class C$H$1,class C,public scala.Function0 C.met()) diff --git a/test/files/jvm/t9105.scala b/test/files/jvm/t9105.scala new file mode 100644 index 0000000000..636ee8a768 --- /dev/null +++ b/test/files/jvm/t9105.scala @@ -0,0 +1,22 @@ +class C { + val fun = () => { + class A + def m: Object = { class B; new B } + val f: Object = { class C; new C } + val g = () => { class D; new D } + List[Object](new A, m, f, g()) + } + def met = () => { + class E + def m: Object = { class F; new F } + val f: Object = { class G; new G } + val g = () => { class H; new H } + List[Object](new E, m, f, g()) + } +} + +object Test extends App { + val x = new C().fun.apply() ::: new C().met.apply() + val results = x.map(_.getClass).map(cls => (cls, cls.getEnclosingClass, cls.getEnclosingMethod)) + println(results.mkString("\n")) +} diff --git a/test/files/jvm/throws-annot-from-java.check b/test/files/jvm/throws-annot-from-java.check index be3ba412f8..c541b26fcc 100644 --- a/test/files/jvm/throws-annot-from-java.check +++ b/test/files/jvm/throws-annot-from-java.check @@ -44,4 +44,4 @@ bar tp.typeParams.isEmpty: true throws[test.PolymorphicException[_]](classOf[test.PolymorphicException]) -scala> +scala> :quit diff --git a/test/files/jvm/varargs.check b/test/files/jvm/varargs.check index 8379befe93..986f98896a 100644 --- a/test/files/jvm/varargs.check +++ b/test/files/jvm/varargs.check @@ -1,3 +1,4 @@ 7 10 -19
\ No newline at end of file +19 +a diff --git a/test/files/jvm/varargs/JavaClass.java b/test/files/jvm/varargs/JavaClass.java index 9851e1b78b..6928ee5adc 100644 --- a/test/files/jvm/varargs/JavaClass.java +++ b/test/files/jvm/varargs/JavaClass.java @@ -11,5 +11,6 @@ public class JavaClass { va.vi(1, 2, 3, 4); varargz(5, 1.0, 2.0, 3.0); va.vt(16, "", "", ""); + System.out.println(va.vt1(16, "a", "b", "c")); } }
\ No newline at end of file diff --git a/test/files/jvm/varargs/VaClass.scala b/test/files/jvm/varargs/VaClass.scala index 6343f9c6f6..d83e63ace1 100644 --- a/test/files/jvm/varargs/VaClass.scala +++ b/test/files/jvm/varargs/VaClass.scala @@ -10,4 +10,6 @@ class VaClass { @varargs def vi(a: Int, b: Int*) = println(a + b.sum) @varargs def vt[T](a: Int, b: T*) = println(a + b.length) + // TODO remove type bound after fixing SI-8786, see also https://github.com/scala/scala/pull/3961 + @varargs def vt1[T <: String](a: Int, b: T*): T = b.head } diff --git a/test/files/jvm/xml05.check b/test/files/jvm/xml05.check index 92ea995350..cad907525d 100644 --- a/test/files/jvm/xml05.check +++ b/test/files/jvm/xml05.check @@ -4,4 +4,4 @@ Type :help for more information. scala> <city name="San José"/> res0: scala.xml.Elem = <city name="San José"/> -scala> +scala> :quit diff --git a/test/files/neg/aladdin1055.check b/test/files/neg/aladdin1055.check new file mode 100644 index 0000000000..41782ae987 --- /dev/null +++ b/test/files/neg/aladdin1055.check @@ -0,0 +1,7 @@ +Test_1.scala:2: warning: match may not be exhaustive. +It would fail on the following input: (_ : this.<local child>) + def foo(t: A.T) = t match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/aladdin1055.flags b/test/files/neg/aladdin1055.flags new file mode 100644 index 0000000000..e8fb65d50c --- /dev/null +++ b/test/files/neg/aladdin1055.flags @@ -0,0 +1 @@ +-Xfatal-warnings
\ No newline at end of file diff --git a/test/files/neg/aladdin1055/A.scala b/test/files/neg/aladdin1055/A.scala new file mode 100644 index 0000000000..862336e30c --- /dev/null +++ b/test/files/neg/aladdin1055/A.scala @@ -0,0 +1,6 @@ +object A { + sealed trait T { def f: Int } + class TT extends T { def f = 0 } + + def foo = new T { def f = 1 } // local subclass of sealed trait T +} diff --git a/test/files/neg/aladdin1055/Test_1.scala b/test/files/neg/aladdin1055/Test_1.scala new file mode 100644 index 0000000000..39d9b1dc98 --- /dev/null +++ b/test/files/neg/aladdin1055/Test_1.scala @@ -0,0 +1,5 @@ +object Test { + def foo(t: A.T) = t match { + case a: A.TT => 0 + } +} diff --git a/test/files/neg/case-collision2.flags b/test/files/neg/case-collision2.flags index 5bfa9da5c5..bea46902c9 100644 --- a/test/files/neg/case-collision2.flags +++ b/test/files/neg/case-collision2.flags @@ -1 +1 @@ --Ynooptimize -Ybackend:GenBCode -Xfatal-warnings +-Ybackend:GenBCode -Xfatal-warnings diff --git a/test/files/neg/checksensible.check b/test/files/neg/checksensible.check index e5f1a38d96..7de22fef54 100644 --- a/test/files/neg/checksensible.check +++ b/test/files/neg/checksensible.check @@ -97,6 +97,7 @@ checksensible.scala:84: warning: comparing values of types EqEqRefTest.this.C3 a checksensible.scala:95: warning: comparing values of types Unit and Int using `!=' will always yield true while ((c = in.read) != -1) ^ +warning: there were three deprecation warnings; re-run with -deprecation for details error: No warnings can be incurred under -Xfatal-warnings. -33 warnings found +34 warnings found one error found diff --git a/test/files/neg/compile-time-only-a.check b/test/files/neg/compile-time-only-a.check index 9bc96f6b9b..b1ed1d24c2 100644 --- a/test/files/neg/compile-time-only-a.check +++ b/test/files/neg/compile-time-only-a.check @@ -4,9 +4,6 @@ compile-time-only-a.scala:10: error: C3 compile-time-only-a.scala:12: error: C4 @compileTimeOnly("C4") case class C4(x: Int) ^ -compile-time-only-a.scala:17: error: C5 - implicit class C5(val x: Int) { - ^ compile-time-only-a.scala:32: error: C1 new C1() ^ @@ -76,4 +73,4 @@ compile-time-only-a.scala:75: error: placebo compile-time-only-a.scala:75: error: placebo @placebo def x = (2: @placebo) ^ -26 errors found +25 errors found diff --git a/test/files/neg/double-def-top-level.check b/test/files/neg/double-def-top-level.check new file mode 100644 index 0000000000..85b16e81e5 --- /dev/null +++ b/test/files/neg/double-def-top-level.check @@ -0,0 +1,7 @@ +D_3.scala:1: error: C is already defined as class C +class C + ^ +D_3.scala:2: error: O is already defined as object O +object O + ^ +two errors found diff --git a/test/files/neg/double-def-top-level/A_1.scala b/test/files/neg/double-def-top-level/A_1.scala new file mode 100644 index 0000000000..c3d68d9d05 --- /dev/null +++ b/test/files/neg/double-def-top-level/A_1.scala @@ -0,0 +1,4 @@ +package p + +class C +object O diff --git a/test/files/neg/double-def-top-level/B_2.scala b/test/files/neg/double-def-top-level/B_2.scala new file mode 100644 index 0000000000..c328e8c964 --- /dev/null +++ b/test/files/neg/double-def-top-level/B_2.scala @@ -0,0 +1,2 @@ +class C /* noerror */ +object O /* noerror */
\ No newline at end of file diff --git a/test/files/neg/double-def-top-level/C_3.scala b/test/files/neg/double-def-top-level/C_3.scala new file mode 100644 index 0000000000..e1c327c15a --- /dev/null +++ b/test/files/neg/double-def-top-level/C_3.scala @@ -0,0 +1,2 @@ +class C +object O
\ No newline at end of file diff --git a/test/files/neg/double-def-top-level/D_3.scala b/test/files/neg/double-def-top-level/D_3.scala new file mode 100644 index 0000000000..518e0d1c54 --- /dev/null +++ b/test/files/neg/double-def-top-level/D_3.scala @@ -0,0 +1,2 @@ +class C +object O diff --git a/test/files/neg/forgot-interpolator.check b/test/files/neg/forgot-interpolator.check index 8988458982..8e75350518 100644 --- a/test/files/neg/forgot-interpolator.check +++ b/test/files/neg/forgot-interpolator.check @@ -1,25 +1,25 @@ -forgot-interpolator.scala:4: warning: `$bippy` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:4: warning: possible missing interpolator: detected interpolated identifier `$bippy` def f = "Put the $bippy in the $bippy!" // warn 1 ^ -forgot-interpolator.scala:14: warning: That looks like an interpolated expression! Did you forget the interpolator? +forgot-interpolator.scala:14: warning: possible missing interpolator: detected an interpolated expression def f = """Put the ${println("bippy")} in the bippy!""" // warn 2 ^ -forgot-interpolator.scala:30: warning: `$beppo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:30: warning: possible missing interpolator: detected interpolated identifier `$beppo` def f = "$beppo was a marx bros who saw dollars." // warn 3 ^ -forgot-interpolator.scala:34: warning: `$aleppo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:34: warning: possible missing interpolator: detected interpolated identifier `$aleppo` def f = "$aleppo is a pepper and a city." // warn 4 ^ -forgot-interpolator.scala:47: warning: `$hippo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:47: warning: possible missing interpolator: detected interpolated identifier `$hippo` def h = "$hippo takes an implicit" // warn 6 ^ -forgot-interpolator.scala:88: warning: `$groucho` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:88: warning: possible missing interpolator: detected interpolated identifier `$groucho` def f2 = "I salute $groucho" // warn 7 ^ -forgot-interpolator.scala:89: warning: `$dingo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:89: warning: possible missing interpolator: detected interpolated identifier `$dingo` def f3 = "I even salute $dingo" // warn 8 ^ -forgot-interpolator.scala:90: warning: `$calico` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:90: warning: possible missing interpolator: detected interpolated identifier `$calico` def f4 = "I also salute $calico" // warn 9 ^ error: No warnings can be incurred under -Xfatal-warnings. diff --git a/test/files/neg/forgot-interpolator.scala b/test/files/neg/forgot-interpolator.scala index a53054d890..ca1ac30821 100644 --- a/test/files/neg/forgot-interpolator.scala +++ b/test/files/neg/forgot-interpolator.scala @@ -54,8 +54,8 @@ package test { } } import annotation._ - @implicitNotFound("No Z in ${A}") // no warn - class Z[A] + @implicitNotFound("No Z in ${T}") // no warn + class Z[T] } diff --git a/test/files/neg/inlineMaxSize.check b/test/files/neg/inlineMaxSize.check new file mode 100644 index 0000000000..d218a8b6e2 --- /dev/null +++ b/test/files/neg/inlineMaxSize.check @@ -0,0 +1,9 @@ +inlineMaxSize.scala:7: warning: C::i()I is annotated @inline but could not be inlined: +The size of the callsite method C::j()I +would exceed the JVM method size limit after inlining C::i()I. + + @inline final def j = i + i + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/inlineMaxSize.flags b/test/files/neg/inlineMaxSize.flags new file mode 100644 index 0000000000..9c6b811622 --- /dev/null +++ b/test/files/neg/inlineMaxSize.flags @@ -0,0 +1 @@ +-Ybackend:GenBCode -Ydelambdafy:method -Yopt:l:classpath -Yopt-warnings -Xfatal-warnings
\ No newline at end of file diff --git a/test/files/neg/inlineMaxSize.scala b/test/files/neg/inlineMaxSize.scala new file mode 100644 index 0000000000..16dc0d9538 --- /dev/null +++ b/test/files/neg/inlineMaxSize.scala @@ -0,0 +1,8 @@ +// not a JUnit test because of https://github.com/scala-opt/scala/issues/23 +class C { + @inline final def f = 0 + @inline final def g = f + f + f + f + f + f + f + f + f + f + @inline final def h = g + g + g + g + g + g + g + g + g + g + @inline final def i = h + h + h + h + h + h + h + h + h + h + @inline final def j = i + i +} diff --git a/test/files/neg/literals.check b/test/files/neg/literals.check new file mode 100644 index 0000000000..148a9346c5 --- /dev/null +++ b/test/files/neg/literals.check @@ -0,0 +1,40 @@ +literals.scala:6: error: missing integer number + def missingHex: Int = { 0x } // line 4: was: not reported, taken as zero + ^ +literals.scala:8: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.) + def leadingZeros: Int = { 01 } // line 6: no leading zero + ^ +literals.scala:10: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.) + def tooManyZeros: Int = { 00 } // line 8: no leading zero + ^ +literals.scala:12: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.) + def zeroOfNine: Int = { 09 } // line 10: no leading zero + ^ +literals.scala:16: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.) + def zeroOfNineDot: Int = { 09. } // line 14: malformed integer, ident expected + ^ +literals.scala:23: error: missing integer number + def missingHex: Int = 0x // line 22: was: not reported, taken as zero + ^ +literals.scala:27: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.) + def tooManyZeros: Int = 00 // line 26: no leading zero + ^ +literals.scala:14: error: identifier expected but '}' found. + def orphanDot: Int = { 9. } // line 12: ident expected + ^ +literals.scala:16: error: identifier expected but '}' found. + def zeroOfNineDot: Int = { 09. } // line 14: malformed integer, ident expected + ^ +literals.scala:18: error: ';' expected but double literal found. + def noHexFloat: Double = { 0x1.2 } // line 16: ';' expected but double literal found. + ^ +literals.scala:25: error: ';' expected but 'def' found. + def leadingZeros: Int = 01 // line 24: no leading zero + ^ +literals.scala:29: error: ';' expected but 'def' found. + def zeroOfNine: Int = 09 // line 28: no leading zero + ^ +literals.scala:33: error: identifier expected but 'def' found. + def zeroOfNineDot: Int = 09. // line 32: malformed integer, ident expected + ^ +13 errors found diff --git a/test/files/neg/literals.scala b/test/files/neg/literals.scala new file mode 100644 index 0000000000..3df7f0b408 --- /dev/null +++ b/test/files/neg/literals.scala @@ -0,0 +1,36 @@ + +/* This took me literally all day. +*/ +trait RejectedLiterals { + + def missingHex: Int = { 0x } // line 4: was: not reported, taken as zero + + def leadingZeros: Int = { 01 } // line 6: no leading zero + + def tooManyZeros: Int = { 00 } // line 8: no leading zero + + def zeroOfNine: Int = { 09 } // line 10: no leading zero + + def orphanDot: Int = { 9. } // line 12: ident expected + + def zeroOfNineDot: Int = { 09. } // line 14: malformed integer, ident expected + + def noHexFloat: Double = { 0x1.2 } // line 16: ';' expected but double literal found. +} + +trait Braceless { + + def missingHex: Int = 0x // line 22: was: not reported, taken as zero + + def leadingZeros: Int = 01 // line 24: no leading zero + + def tooManyZeros: Int = 00 // line 26: no leading zero + + def zeroOfNine: Int = 09 // line 28: no leading zero + + def orphanDot: Int = 9. // line 30: ident expected + + def zeroOfNineDot: Int = 09. // line 32: malformed integer, ident expected + + def noHexFloat: Double = 0x1.2 // line 34: ';' expected but double literal found. +} diff --git a/test/files/neg/literate_existentials.scala b/test/files/neg/literate_existentials.scala index 8580347bf9..5537c50b3a 100644 --- a/test/files/neg/literate_existentials.scala +++ b/test/files/neg/literate_existentials.scala @@ -187,7 +187,7 @@ object LiterateExistentials { // implicitly[Int <:< (M forSome { type M >: Nothing <: String })] // fails -// The preceeding line causes the compiler to generate an error message. +// The preceding line causes the compiler to generate an error message. diff --git a/test/files/neg/macro-basic-mamdmi.check b/test/files/neg/macro-basic-mamdmi.check index 61df5131cc..54743d4936 100644 --- a/test/files/neg/macro-basic-mamdmi.check +++ b/test/files/neg/macro-basic-mamdmi.check @@ -1,5 +1,13 @@ +Impls_Macros_Test_1.scala:33: error: macro implementation not found: foo +(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them) + println(foo(2) + Macros.bar(2) * new Macros().quux(4)) + ^ +Impls_Macros_Test_1.scala:33: error: macro implementation not found: bar +(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them) + println(foo(2) + Macros.bar(2) * new Macros().quux(4)) + ^ Impls_Macros_Test_1.scala:33: error: macro implementation not found: quux (the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them) println(foo(2) + Macros.bar(2) * new Macros().quux(4)) ^ -one error found +three errors found diff --git a/test/files/neg/macro-invalidret.check b/test/files/neg/macro-invalidret.check index 568cc7c570..ebdc8ec7da 100644 --- a/test/files/neg/macro-invalidret.check +++ b/test/files/neg/macro-invalidret.check @@ -19,8 +19,7 @@ Macros_Test_2.scala:7: warning: macro defs must have explicitly specified return def foo6 = macro Impls.foo6 ^ Macros_Test_2.scala:14: error: exception during macro expansion: -scala.NotImplementedError: an implementation is missing - at scala.Predef$.$qmark$qmark$qmark(Predef.scala:225) +java.lang.NullPointerException at Impls$.foo3(Impls_1.scala:7) foo3 diff --git a/test/files/neg/macro-invalidret/Impls_1.scala b/test/files/neg/macro-invalidret/Impls_1.scala index 434aeef10f..a52e8d8f39 100644 --- a/test/files/neg/macro-invalidret/Impls_1.scala +++ b/test/files/neg/macro-invalidret/Impls_1.scala @@ -4,7 +4,7 @@ import scala.reflect.runtime.{universe => ru} object Impls { def foo1(c: Context) = 2 def foo2(c: Context) = ru.Literal(ru.Constant(42)) - def foo3(c: Context) = ??? + def foo3(c: Context) = throw null def foo5(c: Context) = c.universe.Literal(c.universe.Constant(42)) def foo6(c: Context) = c.Expr[Int](c.universe.Literal(c.universe.Constant(42))) } diff --git a/test/files/neg/macro-invalidusage-badargs.check b/test/files/neg/macro-invalidusage-badargs.check index 4c1115418b..19ac6528d3 100644 --- a/test/files/neg/macro-invalidusage-badargs.check +++ b/test/files/neg/macro-invalidusage-badargs.check @@ -9,7 +9,8 @@ Macros_Test_2.scala:6: error: too few argument lists for macro invocation Macros_Test_2.scala:7: error: Int does not take parameters foo(4)(2) ^ -Macros_Test_2.scala:8: error: macro applications do not support named and/or default arguments +Macros_Test_2.scala:8: error: not enough arguments for macro method foo: (x: Int)Int. +Unspecified value parameter x. foo() ^ Macros_Test_2.scala:9: error: too many arguments for macro method foo: (x: Int)Int diff --git a/test/files/neg/names-defaults-neg.check b/test/files/neg/names-defaults-neg.check index 20ddd55f1f..2db24b6f32 100644 --- a/test/files/neg/names-defaults-neg.check +++ b/test/files/neg/names-defaults-neg.check @@ -151,15 +151,15 @@ names-defaults-neg.scala:144: error: variable definition needs type because 'x' names-defaults-neg.scala:147: error: variable definition needs type because 'x' is used as a named argument in its body. object t6 { var x = t.f(x = 1) } ^ -names-defaults-neg.scala:147: warning: type-checking the invocation of method f checks if the named argument expression 'x = ...' is a valid assignment -in the current scope. The resulting type inference error (see above) can be fixed by providing an explicit type in the local definition for x. +names-defaults-neg.scala:147: warning: failed to determine if 'x = ...' is a named argument or an assignment expression. +an explicit type is required for the definition mentioned in the error message above. object t6 { var x = t.f(x = 1) } ^ names-defaults-neg.scala:150: error: variable definition needs type because 'x' is used as a named argument in its body. class t9 { var x = t.f(x = 1) } ^ -names-defaults-neg.scala:150: warning: type-checking the invocation of method f checks if the named argument expression 'x = ...' is a valid assignment -in the current scope. The resulting type inference error (see above) can be fixed by providing an explicit type in the local definition for x. +names-defaults-neg.scala:150: warning: failed to determine if 'x = ...' is a named argument or an assignment expression. +an explicit type is required for the definition mentioned in the error message above. class t9 { var x = t.f(x = 1) } ^ names-defaults-neg.scala:164: error: variable definition needs type because 'x' is used as a named argument in its body. @@ -174,8 +174,8 @@ names-defaults-neg.scala:170: error: reference to x is ambiguous; it is both a m names-defaults-neg.scala:177: error: variable definition needs type because 'x' is used as a named argument in its body. class u15 { var x = u.f(x = 1) } ^ -names-defaults-neg.scala:177: warning: type-checking the invocation of method f checks if the named argument expression 'x = ...' is a valid assignment -in the current scope. The resulting type inference error (see above) can be fixed by providing an explicit type in the local definition for x. +names-defaults-neg.scala:177: warning: failed to determine if 'x = ...' is a named argument or an assignment expression. +an explicit type is required for the definition mentioned in the error message above. class u15 { var x = u.f(x = 1) } ^ names-defaults-neg.scala:180: error: reference to x is ambiguous; it is both a method parameter and a variable in scope. diff --git a/test/files/neg/overloaded-implicit.check b/test/files/neg/overloaded-implicit.check index ca0870705d..0e6617d904 100644 --- a/test/files/neg/overloaded-implicit.check +++ b/test/files/neg/overloaded-implicit.check @@ -4,6 +4,7 @@ overloaded-implicit.scala:2: warning: parameterized overloaded implicit methods overloaded-implicit.scala:3: warning: parameterized overloaded implicit methods are not visible as view bounds implicit def imp1[T](x: Set[T]): Map[T, T] = Map() ^ +warning: there were four feature warnings; re-run with -feature for details error: No warnings can be incurred under -Xfatal-warnings. -two warnings found +three warnings found one error found diff --git a/test/files/neg/patmatexhaust-huge.check b/test/files/neg/patmatexhaust-huge.check new file mode 100644 index 0000000000..66dbd42ef3 --- /dev/null +++ b/test/files/neg/patmatexhaust-huge.check @@ -0,0 +1,7 @@ +patmatexhaust-huge.scala:404: warning: match may not be exhaustive. +It would fail on the following inputs: C392, C397 + def f(c: C): Int = c match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/patmatexhaust-huge.flags b/test/files/neg/patmatexhaust-huge.flags new file mode 100644 index 0000000000..591a950f83 --- /dev/null +++ b/test/files/neg/patmatexhaust-huge.flags @@ -0,0 +1 @@ +-Xfatal-warnings -unchecked -Ypatmat-exhaust-depth off
\ No newline at end of file diff --git a/test/files/neg/patmatexhaust-huge.scala b/test/files/neg/patmatexhaust-huge.scala new file mode 100644 index 0000000000..8f87655b7a --- /dev/null +++ b/test/files/neg/patmatexhaust-huge.scala @@ -0,0 +1,806 @@ +sealed trait C +case object C1 extends C +case object C2 extends C +case object C3 extends C +case object C4 extends C +case object C5 extends C +case object C6 extends C +case object C7 extends C +case object C8 extends C +case object C9 extends C +case object C10 extends C +case object C11 extends C +case object C12 extends C +case object C13 extends C +case object C14 extends C +case object C15 extends C +case object C16 extends C +case object C17 extends C +case object C18 extends C +case object C19 extends C +case object C20 extends C +case object C21 extends C +case object C22 extends C +case object C23 extends C +case object C24 extends C +case object C25 extends C +case object C26 extends C +case object C27 extends C +case object C28 extends C +case object C29 extends C +case object C30 extends C +case object C31 extends C +case object C32 extends C +case object C33 extends C +case object C34 extends C +case object C35 extends C +case object C36 extends C +case object C37 extends C +case object C38 extends C +case object C39 extends C +case object C40 extends C +case object C41 extends C +case object C42 extends C +case object C43 extends C +case object C44 extends C +case object C45 extends C +case object C46 extends C +case object C47 extends C +case object C48 extends C +case object C49 extends C +case object C50 extends C +case object C51 extends C +case object C52 extends C +case object C53 extends C +case object C54 extends C +case object C55 extends C +case object C56 extends C +case object C57 extends C +case object C58 extends C +case object C59 extends C +case object C60 extends C +case object C61 extends C +case object C62 extends C +case object C63 extends C +case object C64 extends C +case object C65 extends C +case object C66 extends C +case object C67 extends C +case object C68 extends C +case object C69 extends C +case object C70 extends C +case object C71 extends C +case object C72 extends C +case object C73 extends C +case object C74 extends C +case object C75 extends C +case object C76 extends C +case object C77 extends C +case object C78 extends C +case object C79 extends C +case object C80 extends C +case object C81 extends C +case object C82 extends C +case object C83 extends C +case object C84 extends C +case object C85 extends C +case object C86 extends C +case object C87 extends C +case object C88 extends C +case object C89 extends C +case object C90 extends C +case object C91 extends C +case object C92 extends C +case object C93 extends C +case object C94 extends C +case object C95 extends C +case object C96 extends C +case object C97 extends C +case object C98 extends C +case object C99 extends C +case object C100 extends C +case object C101 extends C +case object C102 extends C +case object C103 extends C +case object C104 extends C +case object C105 extends C +case object C106 extends C +case object C107 extends C +case object C108 extends C +case object C109 extends C +case object C110 extends C +case object C111 extends C +case object C112 extends C +case object C113 extends C +case object C114 extends C +case object C115 extends C +case object C116 extends C +case object C117 extends C +case object C118 extends C +case object C119 extends C +case object C120 extends C +case object C121 extends C +case object C122 extends C +case object C123 extends C +case object C124 extends C +case object C125 extends C +case object C126 extends C +case object C127 extends C +case object C128 extends C +case object C129 extends C +case object C130 extends C +case object C131 extends C +case object C132 extends C +case object C133 extends C +case object C134 extends C +case object C135 extends C +case object C136 extends C +case object C137 extends C +case object C138 extends C +case object C139 extends C +case object C140 extends C +case object C141 extends C +case object C142 extends C +case object C143 extends C +case object C144 extends C +case object C145 extends C +case object C146 extends C +case object C147 extends C +case object C148 extends C +case object C149 extends C +case object C150 extends C +case object C151 extends C +case object C152 extends C +case object C153 extends C +case object C154 extends C +case object C155 extends C +case object C156 extends C +case object C157 extends C +case object C158 extends C +case object C159 extends C +case object C160 extends C +case object C161 extends C +case object C162 extends C +case object C163 extends C +case object C164 extends C +case object C165 extends C +case object C166 extends C +case object C167 extends C +case object C168 extends C +case object C169 extends C +case object C170 extends C +case object C171 extends C +case object C172 extends C +case object C173 extends C +case object C174 extends C +case object C175 extends C +case object C176 extends C +case object C177 extends C +case object C178 extends C +case object C179 extends C +case object C180 extends C +case object C181 extends C +case object C182 extends C +case object C183 extends C +case object C184 extends C +case object C185 extends C +case object C186 extends C +case object C187 extends C +case object C188 extends C +case object C189 extends C +case object C190 extends C +case object C191 extends C +case object C192 extends C +case object C193 extends C +case object C194 extends C +case object C195 extends C +case object C196 extends C +case object C197 extends C +case object C198 extends C +case object C199 extends C +case object C200 extends C +case object C201 extends C +case object C202 extends C +case object C203 extends C +case object C204 extends C +case object C205 extends C +case object C206 extends C +case object C207 extends C +case object C208 extends C +case object C209 extends C +case object C210 extends C +case object C211 extends C +case object C212 extends C +case object C213 extends C +case object C214 extends C +case object C215 extends C +case object C216 extends C +case object C217 extends C +case object C218 extends C +case object C219 extends C +case object C220 extends C +case object C221 extends C +case object C222 extends C +case object C223 extends C +case object C224 extends C +case object C225 extends C +case object C226 extends C +case object C227 extends C +case object C228 extends C +case object C229 extends C +case object C230 extends C +case object C231 extends C +case object C232 extends C +case object C233 extends C +case object C234 extends C +case object C235 extends C +case object C236 extends C +case object C237 extends C +case object C238 extends C +case object C239 extends C +case object C240 extends C +case object C241 extends C +case object C242 extends C +case object C243 extends C +case object C244 extends C +case object C245 extends C +case object C246 extends C +case object C247 extends C +case object C248 extends C +case object C249 extends C +case object C250 extends C +case object C251 extends C +case object C252 extends C +case object C253 extends C +case object C254 extends C +case object C255 extends C +case object C256 extends C +case object C257 extends C +case object C258 extends C +case object C259 extends C +case object C260 extends C +case object C261 extends C +case object C262 extends C +case object C263 extends C +case object C264 extends C +case object C265 extends C +case object C266 extends C +case object C267 extends C +case object C268 extends C +case object C269 extends C +case object C270 extends C +case object C271 extends C +case object C272 extends C +case object C273 extends C +case object C274 extends C +case object C275 extends C +case object C276 extends C +case object C277 extends C +case object C278 extends C +case object C279 extends C +case object C280 extends C +case object C281 extends C +case object C282 extends C +case object C283 extends C +case object C284 extends C +case object C285 extends C +case object C286 extends C +case object C287 extends C +case object C288 extends C +case object C289 extends C +case object C290 extends C +case object C291 extends C +case object C292 extends C +case object C293 extends C +case object C294 extends C +case object C295 extends C +case object C296 extends C +case object C297 extends C +case object C298 extends C +case object C299 extends C +case object C300 extends C +case object C301 extends C +case object C302 extends C +case object C303 extends C +case object C304 extends C +case object C305 extends C +case object C306 extends C +case object C307 extends C +case object C308 extends C +case object C309 extends C +case object C310 extends C +case object C311 extends C +case object C312 extends C +case object C313 extends C +case object C314 extends C +case object C315 extends C +case object C316 extends C +case object C317 extends C +case object C318 extends C +case object C319 extends C +case object C320 extends C +case object C321 extends C +case object C322 extends C +case object C323 extends C +case object C324 extends C +case object C325 extends C +case object C326 extends C +case object C327 extends C +case object C328 extends C +case object C329 extends C +case object C330 extends C +case object C331 extends C +case object C332 extends C +case object C333 extends C +case object C334 extends C +case object C335 extends C +case object C336 extends C +case object C337 extends C +case object C338 extends C +case object C339 extends C +case object C340 extends C +case object C341 extends C +case object C342 extends C +case object C343 extends C +case object C344 extends C +case object C345 extends C +case object C346 extends C +case object C347 extends C +case object C348 extends C +case object C349 extends C +case object C350 extends C +case object C351 extends C +case object C352 extends C +case object C353 extends C +case object C354 extends C +case object C355 extends C +case object C356 extends C +case object C357 extends C +case object C358 extends C +case object C359 extends C +case object C360 extends C +case object C361 extends C +case object C362 extends C +case object C363 extends C +case object C364 extends C +case object C365 extends C +case object C366 extends C +case object C367 extends C +case object C368 extends C +case object C369 extends C +case object C370 extends C +case object C371 extends C +case object C372 extends C +case object C373 extends C +case object C374 extends C +case object C375 extends C +case object C376 extends C +case object C377 extends C +case object C378 extends C +case object C379 extends C +case object C380 extends C +case object C381 extends C +case object C382 extends C +case object C383 extends C +case object C384 extends C +case object C385 extends C +case object C386 extends C +case object C387 extends C +case object C388 extends C +case object C389 extends C +case object C390 extends C +case object C391 extends C +case object C392 extends C +case object C393 extends C +case object C394 extends C +case object C395 extends C +case object C396 extends C +case object C397 extends C +case object C398 extends C +case object C399 extends C +case object C400 extends C + +object M { + def f(c: C): Int = c match { + case C1 => 1 + case C2 => 2 + case C3 => 3 + case C4 => 4 + case C5 => 5 + case C6 => 6 + case C7 => 7 + case C8 => 8 + case C9 => 9 + case C10 => 10 + case C11 => 11 + case C12 => 12 + case C13 => 13 + case C14 => 14 + case C15 => 15 + case C16 => 16 + case C17 => 17 + case C18 => 18 + case C19 => 19 + case C20 => 20 + case C21 => 21 + case C22 => 22 + case C23 => 23 + case C24 => 24 + case C25 => 25 + case C26 => 26 + case C27 => 27 + case C28 => 28 + case C29 => 29 + case C30 => 30 + case C31 => 31 + case C32 => 32 + case C33 => 33 + case C34 => 34 + case C35 => 35 + case C36 => 36 + case C37 => 37 + case C38 => 38 + case C39 => 39 + case C40 => 40 + case C41 => 41 + case C42 => 42 + case C43 => 43 + case C44 => 44 + case C45 => 45 + case C46 => 46 + case C47 => 47 + case C48 => 48 + case C49 => 49 + case C50 => 50 + case C51 => 51 + case C52 => 52 + case C53 => 53 + case C54 => 54 + case C55 => 55 + case C56 => 56 + case C57 => 57 + case C58 => 58 + case C59 => 59 + case C60 => 60 + case C61 => 61 + case C62 => 62 + case C63 => 63 + case C64 => 64 + case C65 => 65 + case C66 => 66 + case C67 => 67 + case C68 => 68 + case C69 => 69 + case C70 => 70 + case C71 => 71 + case C72 => 72 + case C73 => 73 + case C74 => 74 + case C75 => 75 + case C76 => 76 + case C77 => 77 + case C78 => 78 + case C79 => 79 + case C80 => 80 + case C81 => 81 + case C82 => 82 + case C83 => 83 + case C84 => 84 + case C85 => 85 + case C86 => 86 + case C87 => 87 + case C88 => 88 + case C89 => 89 + case C90 => 90 + case C91 => 91 + case C92 => 92 + case C93 => 93 + case C94 => 94 + case C95 => 95 + case C96 => 96 + case C97 => 97 + case C98 => 98 + case C99 => 99 + case C100 => 100 + case C101 => 101 + case C102 => 102 + case C103 => 103 + case C104 => 104 + case C105 => 105 + case C106 => 106 + case C107 => 107 + case C108 => 108 + case C109 => 109 + case C110 => 110 + case C111 => 111 + case C112 => 112 + case C113 => 113 + case C114 => 114 + case C115 => 115 + case C116 => 116 + case C117 => 117 + case C118 => 118 + case C119 => 119 + case C120 => 120 + case C121 => 121 + case C122 => 122 + case C123 => 123 + case C124 => 124 + case C125 => 125 + case C126 => 126 + case C127 => 127 + case C128 => 128 + case C129 => 129 + case C130 => 130 + case C131 => 131 + case C132 => 132 + case C133 => 133 + case C134 => 134 + case C135 => 135 + case C136 => 136 + case C137 => 137 + case C138 => 138 + case C139 => 139 + case C140 => 140 + case C141 => 141 + case C142 => 142 + case C143 => 143 + case C144 => 144 + case C145 => 145 + case C146 => 146 + case C147 => 147 + case C148 => 148 + case C149 => 149 + case C150 => 150 + case C151 => 151 + case C152 => 152 + case C153 => 153 + case C154 => 154 + case C155 => 155 + case C156 => 156 + case C157 => 157 + case C158 => 158 + case C159 => 159 + case C160 => 160 + case C161 => 161 + case C162 => 162 + case C163 => 163 + case C164 => 164 + case C165 => 165 + case C166 => 166 + case C167 => 167 + case C168 => 168 + case C169 => 169 + case C170 => 170 + case C171 => 171 + case C172 => 172 + case C173 => 173 + case C174 => 174 + case C175 => 175 + case C176 => 176 + case C177 => 177 + case C178 => 178 + case C179 => 179 + case C180 => 180 + case C181 => 181 + case C182 => 182 + case C183 => 183 + case C184 => 184 + case C185 => 185 + case C186 => 186 + case C187 => 187 + case C188 => 188 + case C189 => 189 + case C190 => 190 + case C191 => 191 + case C192 => 192 + case C193 => 193 + case C194 => 194 + case C195 => 195 + case C196 => 196 + case C197 => 197 + case C198 => 198 + case C199 => 199 + case C200 => 200 + case C201 => 201 + case C202 => 202 + case C203 => 203 + case C204 => 204 + case C205 => 205 + case C206 => 206 + case C207 => 207 + case C208 => 208 + case C209 => 209 + case C210 => 210 + case C211 => 211 + case C212 => 212 + case C213 => 213 + case C214 => 214 + case C215 => 215 + case C216 => 216 + case C217 => 217 + case C218 => 218 + case C219 => 219 + case C220 => 220 + case C221 => 221 + case C222 => 222 + case C223 => 223 + case C224 => 224 + case C225 => 225 + case C226 => 226 + case C227 => 227 + case C228 => 228 + case C229 => 229 + case C230 => 230 + case C231 => 231 + case C232 => 232 + case C233 => 233 + case C234 => 234 + case C235 => 235 + case C236 => 236 + case C237 => 237 + case C238 => 238 + case C239 => 239 + case C240 => 240 + case C241 => 241 + case C242 => 242 + case C243 => 243 + case C244 => 244 + case C245 => 245 + case C246 => 246 + case C247 => 247 + case C248 => 248 + case C249 => 249 + case C250 => 250 + case C251 => 251 + case C252 => 252 + case C253 => 253 + case C254 => 254 + case C255 => 255 + case C256 => 256 + case C257 => 257 + case C258 => 258 + case C259 => 259 + case C260 => 260 + case C261 => 261 + case C262 => 262 + case C263 => 263 + case C264 => 264 + case C265 => 265 + case C266 => 266 + case C267 => 267 + case C268 => 268 + case C269 => 269 + case C270 => 270 + case C271 => 271 + case C272 => 272 + case C273 => 273 + case C274 => 274 + case C275 => 275 + case C276 => 276 + case C277 => 277 + case C278 => 278 + case C279 => 279 + case C280 => 280 + case C281 => 281 + case C282 => 282 + case C283 => 283 + case C284 => 284 + case C285 => 285 + case C286 => 286 + case C287 => 287 + case C288 => 288 + case C289 => 289 + case C290 => 290 + case C291 => 291 + case C292 => 292 + case C293 => 293 + case C294 => 294 + case C295 => 295 + case C296 => 296 + case C297 => 297 + case C298 => 298 + case C299 => 299 + case C300 => 300 + case C301 => 301 + case C302 => 302 + case C303 => 303 + case C304 => 304 + case C305 => 305 + case C306 => 306 + case C307 => 307 + case C308 => 308 + case C309 => 309 + case C310 => 310 + case C311 => 311 + case C312 => 312 + case C313 => 313 + case C314 => 314 + case C315 => 315 + case C316 => 316 + case C317 => 317 + case C318 => 318 + case C319 => 319 + case C320 => 320 + case C321 => 321 + case C322 => 322 + case C323 => 323 + case C324 => 324 + case C325 => 325 + case C326 => 326 + case C327 => 327 + case C328 => 328 + case C329 => 329 + case C330 => 330 + case C331 => 331 + case C332 => 332 + case C333 => 333 + case C334 => 334 + case C335 => 335 + case C336 => 336 + case C337 => 337 + case C338 => 338 + case C339 => 339 + case C340 => 340 + case C341 => 341 + case C342 => 342 + case C343 => 343 + case C344 => 344 + case C345 => 345 + case C346 => 346 + case C347 => 347 + case C348 => 348 + case C349 => 349 + case C350 => 350 + case C351 => 351 + case C352 => 352 + case C353 => 353 + case C354 => 354 + case C355 => 355 + case C356 => 356 + case C357 => 357 + case C358 => 358 + case C359 => 359 + case C360 => 360 + case C361 => 361 + case C362 => 362 + case C363 => 363 + case C364 => 364 + case C365 => 365 + case C366 => 366 + case C367 => 367 + case C368 => 368 + case C369 => 369 + case C370 => 370 + case C371 => 371 + case C372 => 372 + case C373 => 373 + case C374 => 374 + case C375 => 375 + case C376 => 376 + case C377 => 377 + case C378 => 378 + case C379 => 379 + case C380 => 380 + case C381 => 381 + case C382 => 382 + case C383 => 383 + case C384 => 384 + case C385 => 385 + case C386 => 386 + case C387 => 387 + case C388 => 388 + case C389 => 389 + case C390 => 390 + case C391 => 391 +// case C392 => 392 + case C393 => 393 + case C394 => 394 + case C395 => 395 + case C396 => 396 +// case C397 => 397 + case C398 => 398 + case C399 => 399 + case C400 => 400 + } +} diff --git a/test/files/neg/patmatexhaust.check b/test/files/neg/patmatexhaust.check index 2dad608451..bbf5e9b528 100644 --- a/test/files/neg/patmatexhaust.check +++ b/test/files/neg/patmatexhaust.check @@ -12,7 +12,7 @@ It would fail on the following inputs: (Kult(_), Kult(_)), (Qult(), Qult()) ^ patmatexhaust.scala:49: warning: match may not be exhaustive. It would fail on the following inputs: Gp(), Gu - def ma4(x:Deep) = x match { // missing cases: Gu, Gp + def ma4(x:Deep) = x match { // missing cases: Gu, Gp which is not abstract so must be included ^ patmatexhaust.scala:55: warning: unreachable code case _ if 1 == 0 => diff --git a/test/files/neg/patmatexhaust.flags b/test/files/neg/patmatexhaust.flags index 85d8eb2ba2..3b01ca062c 100644 --- a/test/files/neg/patmatexhaust.flags +++ b/test/files/neg/patmatexhaust.flags @@ -1 +1 @@ --Xfatal-warnings +-Xfatal-warnings -Ypatmat-exhaust-depth off
\ No newline at end of file diff --git a/test/files/neg/patmatexhaust.scala b/test/files/neg/patmatexhaust.scala index f937197829..26f0c12a91 100644 --- a/test/files/neg/patmatexhaust.scala +++ b/test/files/neg/patmatexhaust.scala @@ -46,7 +46,7 @@ class TestSealedExhaustive { // compile only case _ => } - def ma4(x:Deep) = x match { // missing cases: Gu, Gp + def ma4(x:Deep) = x match { // missing cases: Gu, Gp which is not abstract so must be included case Ga => } diff --git a/test/files/neg/reflection-names-neg.check b/test/files/neg/reflection-names-neg.check deleted file mode 100644 index f941ec8dc1..0000000000 --- a/test/files/neg/reflection-names-neg.check +++ /dev/null @@ -1,13 +0,0 @@ -reflection-names-neg.scala:5: error: type mismatch; - found : String("abc") - required: reflect.runtime.universe.Name -Note that implicit conversions are not applicable because they are ambiguous: - both method stringToTermName in trait Names of type (s: String)reflect.runtime.universe.TermName - and method stringToTypeName in trait Names of type (s: String)reflect.runtime.universe.TypeName - are possible conversion functions from String("abc") to reflect.runtime.universe.Name - val x2 = ("abc": Name) drop 1 // error - ^ -reflection-names-neg.scala:5: error: value drop is not a member of reflect.runtime.universe.Name - val x2 = ("abc": Name) drop 1 // error - ^ -two errors found diff --git a/test/files/neg/reflection-names-neg.scala b/test/files/neg/reflection-names-neg.scala deleted file mode 100644 index 7283d16db9..0000000000 --- a/test/files/neg/reflection-names-neg.scala +++ /dev/null @@ -1,6 +0,0 @@ -import scala.reflect.runtime.universe._ - -object Test { - val x1 = "abc" drop 1 // "bc": String - val x2 = ("abc": Name) drop 1 // error -} diff --git a/test/files/neg/sammy_error_exist_no_crash.check b/test/files/neg/sammy_error_exist_no_crash.check new file mode 100644 index 0000000000..a0d2237ce0 --- /dev/null +++ b/test/files/neg/sammy_error_exist_no_crash.check @@ -0,0 +1,6 @@ +sammy_error_exist_no_crash.scala:5: error: Could not derive subclass of F[? >: String] + (with SAM `def method apply(s: String)Int`) + based on: ((x$1: String) => x$1.<parseInt: error>). + bar(_.parseInt) + ^ +one error found diff --git a/test/files/run/t5530.flags b/test/files/neg/sammy_error_exist_no_crash.flags index e1b37447c9..e1b37447c9 100644 --- a/test/files/run/t5530.flags +++ b/test/files/neg/sammy_error_exist_no_crash.flags diff --git a/test/files/neg/sammy_error_exist_no_crash.scala b/test/files/neg/sammy_error_exist_no_crash.scala new file mode 100644 index 0000000000..da7e47206f --- /dev/null +++ b/test/files/neg/sammy_error_exist_no_crash.scala @@ -0,0 +1,6 @@ +abstract class F[T] { def apply(s: T): Int } + +object NeedsNiceError { + def bar(x: F[_ >: String]) = ??? + bar(_.parseInt) +}
\ No newline at end of file diff --git a/test/files/neg/sammy_restrictions.scala b/test/files/neg/sammy_restrictions.scala index 5f1a04cd20..d003cfaf36 100644 --- a/test/files/neg/sammy_restrictions.scala +++ b/test/files/neg/sammy_restrictions.scala @@ -1,28 +1,28 @@ -class NoAbstract +abstract class NoAbstract -class TwoAbstract { def ap(a: Int): Int; def pa(a: Int): Int } +abstract class TwoAbstract { def ap(a: Int): Int; def pa(a: Int): Int } -class Base // check that the super class constructor isn't considered. -class NoEmptyConstructor(a: Int) extends Base { def this(a: String) = this(0); def ap(a: Int): Int } +abstract class Base // check that the super class constructor isn't considered. +abstract class NoEmptyConstructor(a: Int) extends Base { def this(a: String) = this(0); def ap(a: Int): Int } -class OneEmptyConstructor() { def this(a: Int) = this(); def ap(a: Int): Int } +abstract class OneEmptyConstructor() { def this(a: Int) = this(); def ap(a: Int): Int } -class OneEmptySecondaryConstructor(a: Int) { def this() = this(0); def ap(a: Int): Int } +abstract class OneEmptySecondaryConstructor(a: Int) { def this() = this(0); def ap(a: Int): Int } -class MultipleConstructorLists()() { def ap(a: Int): Int } +abstract class MultipleConstructorLists()() { def ap(a: Int): Int } -class MultipleMethodLists()() { def ap(a: Int)(): Int } +abstract class MultipleMethodLists()() { def ap(a: Int)(): Int } -class ImplicitConstructorParam()(implicit a: String) { def ap(a: Int): Int } +abstract class ImplicitConstructorParam()(implicit a: String) { def ap(a: Int): Int } -class ImplicitMethodParam() { def ap(a: Int)(implicit b: String): Int } +abstract class ImplicitMethodParam() { def ap(a: Int)(implicit b: String): Int } -class PolyClass[T] { def ap(a: T): T } +abstract class PolyClass[T] { def ap(a: T): T } -class PolyMethod { def ap[T](a: T): T } +abstract class PolyMethod { def ap[T](a: T): T } -class OneAbstract { def ap(a: Any): Any } -class DerivedOneAbstract extends OneAbstract +abstract class OneAbstract { def ap(a: Int): Any } +abstract class DerivedOneAbstract extends OneAbstract object Test { implicit val s: String = "" diff --git a/test/files/neg/structural.scala b/test/files/neg/structural.scala index d783399317..00459676a9 100644 --- a/test/files/neg/structural.scala +++ b/test/files/neg/structural.scala @@ -11,13 +11,13 @@ object Test extends App { def f2[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: B): Object; val x: B }) = x.m[Tata](x.x) //fail def f3[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: C): Object; val x: C }) = x.m[Tata](x.x) //fail def f4[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: D): Object; val x: D }) = x.m[Tata](x.x) //fail - def f5[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: E): Object; val x: Tata }) = x.m[Tata](x.x) //suceed + def f5[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: E): Object; val x: Tata }) = x.m[Tata](x.x) //succeeds - def f6[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): A }) = x.m[Tata](null) //suceed - def f7[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): B }) = x.m[Tata](null) //suceed - def f8[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): C }) = x.m[Tata](null) //suceed + def f6[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): A }) = x.m[Tata](null) //succeeds + def f7[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): B }) = x.m[Tata](null) //succeeds + def f8[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): C }) = x.m[Tata](null) //succeeds def f9[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): D }) = x.m[Tata](null) //fail - def f0[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): E }) = x.m[Tata](null) //suceed + def f0[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): E }) = x.m[Tata](null) //succeeds } diff --git a/test/files/neg/t0899.check b/test/files/neg/t0899.check index 8b71be8e0c..28cb06ae5a 100644 --- a/test/files/neg/t0899.check +++ b/test/files/neg/t0899.check @@ -1,10 +1,10 @@ -t0899.scala:9: error: super may be not be used on value o +t0899.scala:9: error: super may not be used on value o override val o = "Ha! " + super.o ^ -t0899.scala:11: error: super may be not be used on variable v +t0899.scala:11: error: super may not be used on variable v super.v = "aa" ^ -t0899.scala:12: error: super may be not be used on variable v +t0899.scala:12: error: super may not be used on variable v println(super.v) ^ three errors found diff --git a/test/files/neg/t1909-object.check b/test/files/neg/t1909-object.check index 401c1f7ebf..7141c84d4b 100644 --- a/test/files/neg/t1909-object.check +++ b/test/files/neg/t1909-object.check @@ -1,4 +1,6 @@ -t1909-object.scala:4: error: !!! SI-1909 Unable to STATICally lift object InnerTrouble$1, which is defined in the self- or super-constructor call of class Kaboom. A VerifyError is likely. +t1909-object.scala:4: warning: !!! SI-1909 Unable to STATICally lift object InnerTrouble$1, which is defined in the self- or super-constructor call of class Kaboom. A VerifyError is likely. object InnerTrouble ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found one error found diff --git a/test/files/neg/t2866.check b/test/files/neg/t2866.check new file mode 100644 index 0000000000..340fb8da22 --- /dev/null +++ b/test/files/neg/t2866.check @@ -0,0 +1,17 @@ +t2866.scala:30: warning: imported `one' is permanently hidden by definition of value one + import A.one // warning: imported `one' is permanently hidden by definition of value one. + ^ +t2866.scala:42: error: ambiguous implicit values: + both value two of type Int + and value one in object A of type => Int + match expected type Int + assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambigous in 2.7.6 + ^ +t2866.scala:50: error: ambiguous implicit values: + both value two of type Int + and value one in object A of type => Int + match expected type Int + assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambiguous in 2.7.6 + ^ +one warning found +two errors found diff --git a/test/files/neg/t2866.scala b/test/files/neg/t2866.scala new file mode 100644 index 0000000000..55ebff9710 --- /dev/null +++ b/test/files/neg/t2866.scala @@ -0,0 +1,59 @@ +// for 2.7.x compatibility + +object A { + implicit val one = 1 +} + +object Test { + + locally { + import A._ + locally { + // assert(implicitly[Int] == 1) // error: could not find implicit value for parameter e: Int. + // !!! Why one A.one? + // (I assume you mean: why _not_ A.one? A.one is shadowed by local one. + // but the local one cannot be used yet because it does not have an explicit type. + implicit val one = 2 + assert(implicitly[Int] == 2) + assert(one == 2) + } + } + + locally { + import A._ + implicit val one: Int = 2 + assert(implicitly[Int] == 2) + assert(one == 2) + } + + locally { + import A.one // warning: imported `one' is permanently hidden by definition of value one. + // !!! Really? + //assert(implicitly[Int] == 1) + implicit val one = 2 + assert(implicitly[Int] == 2) // !!! why not 2? + assert(one == 2) + } + + locally { + import A.one + assert(implicitly[Int] == 1) + implicit val two = 2 + assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambigous in 2.7.6 + } + + locally { + import A._ + assert(implicitly[Int] == 1) + implicit val two = 2 + import A.{one => _} + assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambiguous in 2.7.6 + } + + locally { + import A.{one => _, _} + implicit val two = 2 + assert(implicitly[Int] == 2) // not ambiguous in 2.8.0 nor im ambiguous in 2.7.6 + } + +} diff --git a/test/files/neg/t3240.check b/test/files/neg/t3240.check deleted file mode 100644 index efae682c66..0000000000 --- a/test/files/neg/t3240.check +++ /dev/null @@ -1,4 +0,0 @@ -t3240.scala:3: error: only classes can have declared but undefined members - type t - ^ -one error found diff --git a/test/files/neg/t3909.check b/test/files/neg/t3909.check index 7da0195607..052b49f855 100644 --- a/test/files/neg/t3909.check +++ b/test/files/neg/t3909.check @@ -1,4 +1,5 @@ t3909.scala:1: error: in object DO, multiple overloaded alternatives of m1 define default arguments +Error occurred in an application involving default arguments. object DO { ^ one error found diff --git a/test/files/neg/t4851.check b/test/files/neg/t4851.check index 132dd91b50..d5711a889b 100644 --- a/test/files/neg/t4851.check +++ b/test/files/neg/t4851.check @@ -29,13 +29,13 @@ S.scala:7: warning: Adapting argument list by creating a 3-tuple: this may not b val y2 = new Some(1, 2, 3) ^ S.scala:9: warning: Adaptation of argument list by inserting () has been deprecated: this is unlikely to be what you want. - signature: J2[T](x: T): J2[T] + signature: J2(x: T): J2[T] given arguments: <none> after adaptation: new J2((): Unit) val z1 = new J2 ^ S.scala:10: warning: Adaptation of argument list by inserting () has been deprecated: this is unlikely to be what you want. - signature: J2[T](x: T): J2[T] + signature: J2(x: T): J2[T] given arguments: <none> after adaptation: new J2((): Unit) val z2 = new J2() diff --git a/test/files/neg/t4851.flags b/test/files/neg/t4851.flags index ca0d0a0ba3..044ce22c84 100644 --- a/test/files/neg/t4851.flags +++ b/test/files/neg/t4851.flags @@ -1 +1 @@ --Ywarn-adapted-args -Xfatal-warnings -deprecation +-Xlint:adapted-args -Xfatal-warnings -deprecation diff --git a/test/files/neg/t4851/J2.java b/test/files/neg/t4851/J2.java index 82954d9489..a90f48e269 100644 --- a/test/files/neg/t4851/J2.java +++ b/test/files/neg/t4851/J2.java @@ -1,11 +1,11 @@ public class J2<T> { T x; - public <T> J(T x) { + public J2(T x) { this.x = x; } public String toString() { return "J2:" + x.getClass(); } -}
\ No newline at end of file +} diff --git a/test/files/neg/t5044.check b/test/files/neg/t5044.check index 197da2a4e8..dc3708123f 100644 --- a/test/files/neg/t5044.check +++ b/test/files/neg/t5044.check @@ -1,8 +1,8 @@ t5044.scala:7: error: recursive value a needs type val id = m(a) ^ -t5044.scala:6: warning: type-checking the invocation of method foo checks if the named argument expression 'id = ...' is a valid assignment -in the current scope. The resulting type inference error (see above) can be fixed by providing an explicit type in the local definition for id. +t5044.scala:6: warning: failed to determine if 'id = ...' is a named argument or an assignment expression. +an explicit type is required for the definition mentioned in the error message above. val a = foo(id = 1) ^ one warning found diff --git a/test/files/neg/t5091.check b/test/files/neg/t5091.check new file mode 100644 index 0000000000..156f695f41 --- /dev/null +++ b/test/files/neg/t5091.check @@ -0,0 +1,9 @@ +t5091.scala:8: error: recursive value xxx needs type + val param = bar(xxx) + ^ +t5091.scala:7: warning: failed to determine if 'param = ...' is a named argument or an assignment expression. +an explicit type is required for the definition mentioned in the error message above. + val xxx = foo(param = null) + ^ +one warning found +one error found diff --git a/test/files/neg/t5091.scala b/test/files/neg/t5091.scala new file mode 100644 index 0000000000..217e83f66d --- /dev/null +++ b/test/files/neg/t5091.scala @@ -0,0 +1,11 @@ +object RecursiveValueNeedsType { + + def foo(param: String) = 42 + def bar(n: Int) = 42 + + { + val xxx = foo(param = null) + val param = bar(xxx) + } + +} diff --git a/test/files/neg/t5148.check b/test/files/neg/t5148.check index 8a667f4b88..286ed9e04a 100644 --- a/test/files/neg/t5148.check +++ b/test/files/neg/t5148.check @@ -1,5 +1,11 @@ -error: bad symbolic reference to scala.tools.nsc.interpreter.IMain.Request encountered in class file 'Imports.class'. -Cannot access type Request in class scala.tools.nsc.interpreter.IMain. The current classpath may be -missing a definition for scala.tools.nsc.interpreter.IMain.Request, or Imports.class may have been compiled against a version that's -incompatible with the one found on the current classpath. -one error found +error: missing or invalid dependency detected while loading class file 'Imports.class'. +Could not access type Wrapper in class scala.tools.nsc.interpreter.IMain.Request, +because it (or its dependencies) are missing. Check your build definition for +missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.) +A full rebuild may help if 'Imports.class' was compiled against an incompatible version of scala.tools.nsc.interpreter.IMain.Request. +error: missing or invalid dependency detected while loading class file 'Imports.class'. +Could not access type Request in class scala.tools.nsc.interpreter.IMain, +because it (or its dependencies) are missing. Check your build definition for +missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.) +A full rebuild may help if 'Imports.class' was compiled against an incompatible version of scala.tools.nsc.interpreter.IMain. +two errors found diff --git a/test/files/neg/t562.check b/test/files/neg/t562.check index 8c3823642a..95be075af1 100644 --- a/test/files/neg/t562.check +++ b/test/files/neg/t562.check @@ -1,4 +1,4 @@ -t562.scala:10: error: super may be not be used on value y +t562.scala:10: error: super may not be used on value y override val y = super.y; ^ one error found diff --git a/test/files/neg/t5639b.check b/test/files/neg/t5639b.check new file mode 100644 index 0000000000..faa1766660 --- /dev/null +++ b/test/files/neg/t5639b.check @@ -0,0 +1,4 @@ +A_2.scala:6: error: could not find implicit value for parameter e: Int + implicitly[Int] + ^ +one error found diff --git a/test/files/neg/t5639b/A_1.scala b/test/files/neg/t5639b/A_1.scala new file mode 100644 index 0000000000..c5da10eae4 --- /dev/null +++ b/test/files/neg/t5639b/A_1.scala @@ -0,0 +1,17 @@ +import Implicits._ + +class Baz + +object Test { + implicitly[Int] +} + +object Implicits { + implicit val Baz: Int = 0 + // This implicit was being ignored by `isQualifyingImplicit` + // if the classpath contained a class file for `class Baz`. + // This is because the package scope contains a speculative + // symbol for `object Baz` which is entered by `SymbolLoaders` + // before looking inside the class file. (A Java originated + // classfile results in the class/module symbol pair.) +} diff --git a/test/files/neg/t5639b/A_2.scala b/test/files/neg/t5639b/A_2.scala new file mode 100644 index 0000000000..2bb36273e0 --- /dev/null +++ b/test/files/neg/t5639b/A_2.scala @@ -0,0 +1,11 @@ +import Implicits._ + +class Baz + +object Test { + implicitly[Int] +} + +object Implicits { + implicit val Baz: Int = 0 +} diff --git a/test/files/neg/t5675.check b/test/files/neg/t5675.check index da608a2b78..3b3b2fa04c 100644 --- a/test/files/neg/t5675.check +++ b/test/files/neg/t5675.check @@ -1,2 +1,4 @@ -error: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details +error: No warnings can be incurred under -Xfatal-warnings. +one warning found one error found diff --git a/test/files/neg/t5691.check b/test/files/neg/t5691.check new file mode 100644 index 0000000000..a51ca98a10 --- /dev/null +++ b/test/files/neg/t5691.check @@ -0,0 +1,24 @@ +t5691.scala:7: warning: type parameter D defined in method foobar shadows trait D defined in class B. You may want to rename your type parameter, or possibly remove it. + def foobar[D](in: D) = in.toString + ^ +t5691.scala:10: warning: type parameter D defined in type MySeq shadows trait D defined in class B. You may want to rename your type parameter, or possibly remove it. + type MySeq[D] = Seq[D] + ^ +t5691.scala:15: warning: type parameter T defined in method bar shadows type T defined in class Foo. You may want to rename your type parameter, or possibly remove it. + def bar[T](w: T) = w.toString + ^ +t5691.scala:13: warning: type parameter T defined in class Foo shadows type T defined in class B. You may want to rename your type parameter, or possibly remove it. + class Foo[T](t: T) { + ^ +t5691.scala:19: warning: type parameter List defined in type M shadows type List defined in package object scala. You may want to rename your type parameter, or possibly remove it. + class C[M[List[_]]] + ^ +t5691.scala:20: warning: type parameter List defined in type M shadows type List defined in package object scala. You may want to rename your type parameter, or possibly remove it. + type E[M[List[_]]] = Int + ^ +t5691.scala:21: warning: type parameter List defined in type M shadows type List defined in package object scala. You may want to rename your type parameter, or possibly remove it. + def foo[N[M[List[_]]]] = ??? + ^ +error: No warnings can be incurred under -Xfatal-warnings. +7 warnings found +one error found diff --git a/test/files/neg/t5691.flags b/test/files/neg/t5691.flags new file mode 100644 index 0000000000..0e09b8575b --- /dev/null +++ b/test/files/neg/t5691.flags @@ -0,0 +1 @@ +-Xlint:type-parameter-shadow -language:higherKinds -Xfatal-warnings diff --git a/test/files/neg/t5691.scala b/test/files/neg/t5691.scala new file mode 100644 index 0000000000..e6a9bdc16a --- /dev/null +++ b/test/files/neg/t5691.scala @@ -0,0 +1,27 @@ +class B { + + type T = Int + trait D + + // method parameter shadows some other type + def foobar[D](in: D) = in.toString + + // type member's parameter shadows some other type + type MySeq[D] = Seq[D] + + // class parameter shadows some other type + class Foo[T](t: T) { + // a type parameter shadows another type parameter + def bar[T](w: T) = w.toString + } + + // even deeply nested... + class C[M[List[_]]] + type E[M[List[_]]] = Int + def foo[N[M[List[_]]]] = ??? + + // ...but not between type parameters in the same list + class F[A, M[L[A]]] // no warning! + type G[A, M[L[A]]] = Int // no warning! + def bar[A, N[M[L[A]]]] = ??? // no warning! +} diff --git a/test/files/neg/t6162-inheritance.check b/test/files/neg/t6162-inheritance.check index 13c78030d9..c9f4ddaec1 100644 --- a/test/files/neg/t6162-inheritance.check +++ b/test/files/neg/t6162-inheritance.check @@ -7,12 +7,6 @@ object SubT extends T usage.scala:8: warning: inheritance from trait S in package t6126 is deprecated new S { ^ -usage.scala:3: warning: inheritance from class Foo in package t6126 is deprecated: `Foo` will be made final in a future version. -class SubFoo extends Foo - ^ -usage.scala:5: warning: inheritance from trait T in package t6126 is deprecated -object SubT extends T - ^ error: No warnings can be incurred under -Xfatal-warnings. -5 warnings found +three warnings found one error found diff --git a/test/files/neg/t6289.check b/test/files/neg/t6289.check index f6f43cabd3..989932750f 100644 --- a/test/files/neg/t6289.check +++ b/test/files/neg/t6289.check @@ -3,7 +3,7 @@ t6289/J.java:2: method does not override or implement a method from a supertype @Override public void foo() { } ^ 1 error -#partest java7 +#partest !java6 t6289/J.java:2: error: method does not override or implement a method from a supertype @Override public void foo() { } ^ diff --git a/test/files/neg/t6567.check b/test/files/neg/t6567.check index a733d75354..f42f157371 100644 --- a/test/files/neg/t6567.check +++ b/test/files/neg/t6567.check @@ -4,6 +4,7 @@ t6567.scala:8: warning: Suspicious application of an implicit view (Test.this.a2 t6567.scala:10: warning: Suspicious application of an implicit view (Test.this.a2b) in the argument to Option.apply. val b: Option[B] = Option(a) ^ +warning: there was one feature warning; re-run with -feature for details error: No warnings can be incurred under -Xfatal-warnings. -two warnings found +three warnings found one error found diff --git a/test/files/neg/t6582_exhaust_big.check b/test/files/neg/t6582_exhaust_big.check new file mode 100644 index 0000000000..9e2be038b5 --- /dev/null +++ b/test/files/neg/t6582_exhaust_big.check @@ -0,0 +1,7 @@ +t6582_exhaust_big.scala:27: warning: match may not be exhaustive. +It would fail on the following input: Z11() + def foo(z: Z) = z match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t6582_exhaust_big.flags b/test/files/neg/t6582_exhaust_big.flags new file mode 100644 index 0000000000..b5a8748652 --- /dev/null +++ b/test/files/neg/t6582_exhaust_big.flags @@ -0,0 +1 @@ +-Xfatal-warnings -unchecked diff --git a/test/files/neg/t6582_exhaust_big.scala b/test/files/neg/t6582_exhaust_big.scala new file mode 100644 index 0000000000..dd639eb56e --- /dev/null +++ b/test/files/neg/t6582_exhaust_big.scala @@ -0,0 +1,32 @@ +sealed abstract class Z +object Z { + object Z0 extends Z + case class Z1() extends Z + object Z2 extends Z + case class Z3() extends Z + object Z4 extends Z + case class Z5() extends Z + object Z6 extends Z + case class Z7() extends Z + object Z8 extends Z + case class Z9() extends Z + object Z10 extends Z + case class Z11() extends Z + object Z12 extends Z + case class Z13() extends Z + object Z14 extends Z + case class Z15() extends Z + object Z16 extends Z + case class Z17() extends Z + object Z18 extends Z + case class Z19() extends Z +} + +object Test { + import Z._ + def foo(z: Z) = z match { + case Z0 | Z1() | Z2 | Z3() | Z4 | Z5() | Z6 | Z7() | Z8 | Z9() | + Z10 | Z12 | Z13() | Z14 | Z15() | Z16 | Z17() | Z18 | Z19() + => + } +} diff --git a/test/files/neg/t6675b.scala b/test/files/neg/t6675b.scala index c86c9c3955..da27e1b91f 100644 --- a/test/files/neg/t6675b.scala +++ b/test/files/neg/t6675b.scala @@ -13,7 +13,7 @@ object NativelyTwo { } -class A { +class E { def f1 = (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { case LeftOrRight(a) => a } // warn def f2 = (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { case LeftOrRight((a, b)) => a } // no warn def f3 = (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { case LeftOrRight((a, b, c)) => a } // fail diff --git a/test/files/neg/t6771b.check b/test/files/neg/t6771b.check index ba99e9178d..0c9fae533e 100644 --- a/test/files/neg/t6771b.check +++ b/test/files/neg/t6771b.check @@ -1,4 +1,4 @@ -t6771b.scala:14: error: type mismatch; +t6771b.scala:12: error: type mismatch; found : x.type (with underlying type String) required: Test.a.type b = b match { case x => x } diff --git a/test/files/neg/t6771b.scala b/test/files/neg/t6771b.scala index 78f11f7750..9723f70290 100644 --- a/test/files/neg/t6771b.scala +++ b/test/files/neg/t6771b.scala @@ -6,8 +6,6 @@ // But, to the intrepid hacker who works on this, a few notes: // You'll have to look into places in the pattern matcher that // call `dealias`, and see if they need to be `dealiasWiden`. -// For example, if `checkableType` used only `dealias`, `pos/t6671.scala` -// would fail. object Test { val a = ""; var b: a.type = a diff --git a/test/files/neg/t6902.scala b/test/files/neg/t6902.scala index ce5ff8b6fb..627c324279 100644 --- a/test/files/neg/t6902.scala +++ b/test/files/neg/t6902.scala @@ -16,7 +16,7 @@ object Test { // at scala.reflect.internal.SymbolTable.abort(SymbolTable.scala:50) // at scala.tools.nsc.Global.abort(Global.scala:249) // at scala.tools.nsc.backend.jvm.GenASM$JPlainBuilder$jcode$.emitSWITCH(GenASM.scala:1850) - ((1: Byte): @unchecked @annotation.switch) match { + ((1: Byte): @unchecked) match { case 1 => 2 case 1 => 3 // crash } diff --git a/test/files/neg/t6988.check b/test/files/neg/t6988.check new file mode 100644 index 0000000000..acb7b3cb08 --- /dev/null +++ b/test/files/neg/t6988.check @@ -0,0 +1,7 @@ +t6988.scala:3: error: annotation argument needs to be a constant; found: 13.asInstanceOf[Long] +@SerialVersionUID(13.asInstanceOf[Long]) case class IdentifyMessage1(userName: String, user: User, code: Int) + ^ +t6988.scala:8: error: annotation argument needs to be a constant; found: O.SerialUID +@SerialVersionUID(O.SerialUID) case class IdentifyMessage3(userName: String, user: User, code: Int) + ^ +two errors found diff --git a/test/files/neg/t6988.scala b/test/files/neg/t6988.scala new file mode 100644 index 0000000000..8171dc9dd0 --- /dev/null +++ b/test/files/neg/t6988.scala @@ -0,0 +1,10 @@ +case class User() + +@SerialVersionUID(13.asInstanceOf[Long]) case class IdentifyMessage1(userName: String, user: User, code: Int) +@SerialVersionUID(13l) case class IdentifyMessage2(userName: String, user: User, code: Int) +object O { + val SerialUID = "13".toLong +} +@SerialVersionUID(O.SerialUID) case class IdentifyMessage3(userName: String, user: User, code: Int) + + diff --git a/test/files/neg/t7157.check b/test/files/neg/t7157.check index c6a7af9a23..3988460d4b 100644 --- a/test/files/neg/t7157.check +++ b/test/files/neg/t7157.check @@ -7,7 +7,8 @@ Test_2.scala:6: error: too many arguments for macro method m1_0_0: ()Unit Test_2.scala:7: error: too many arguments for macro method m1_0_0: ()Unit m1_0_0(1, 2, 3) ^ -Test_2.scala:9: error: macro applications do not support named and/or default arguments +Test_2.scala:9: error: not enough arguments for macro method m1_1_1: (x: Int)Unit. +Unspecified value parameter x. m1_1_1() ^ Test_2.scala:11: error: too many arguments for macro method m1_1_1: (x: Int)Unit @@ -16,22 +17,27 @@ Test_2.scala:11: error: too many arguments for macro method m1_1_1: (x: Int)Unit Test_2.scala:12: error: too many arguments for macro method m1_1_1: (x: Int)Unit m1_1_1(1, 2, 3) ^ -Test_2.scala:14: error: macro applications do not support named and/or default arguments +Test_2.scala:14: error: not enough arguments for macro method m1_2_2: (x: Int, y: Int)Unit. +Unspecified value parameters x, y. m1_2_2() ^ -Test_2.scala:15: error: macro applications do not support named and/or default arguments +Test_2.scala:15: error: not enough arguments for macro method m1_2_2: (x: Int, y: Int)Unit. +Unspecified value parameter y. m1_2_2(1) ^ Test_2.scala:17: error: too many arguments for macro method m1_2_2: (x: Int, y: Int)Unit m1_2_2(1, 2, 3) ^ -Test_2.scala:24: error: macro applications do not support named and/or default arguments +Test_2.scala:24: error: not enough arguments for macro method m1_1_inf: (x: Int, y: Int*)Unit. +Unspecified value parameters x, y. m1_1_inf() ^ -Test_2.scala:29: error: macro applications do not support named and/or default arguments +Test_2.scala:29: error: not enough arguments for macro method m1_2_inf: (x: Int, y: Int, z: Int*)Unit. +Unspecified value parameters x, y, z. m1_2_inf() ^ -Test_2.scala:30: error: macro applications do not support named and/or default arguments +Test_2.scala:30: error: not enough arguments for macro method m1_2_inf: (x: Int, y: Int, z: Int*)Unit. +Unspecified value parameters y, z. m1_2_inf(1) ^ Test_2.scala:35: error: too many arguments for macro method m2_0_0: ()Unit @@ -43,7 +49,8 @@ Test_2.scala:36: error: too many arguments for macro method m2_0_0: ()Unit Test_2.scala:37: error: too many arguments for macro method m2_0_0: ()Unit m2_0_0()(1, 2, 3) ^ -Test_2.scala:39: error: macro applications do not support named and/or default arguments +Test_2.scala:39: error: not enough arguments for macro method m2_1_1: (x: Int)Unit. +Unspecified value parameter x. m2_1_1()() ^ Test_2.scala:41: error: too many arguments for macro method m2_1_1: (x: Int)Unit @@ -52,22 +59,27 @@ Test_2.scala:41: error: too many arguments for macro method m2_1_1: (x: Int)Unit Test_2.scala:42: error: too many arguments for macro method m2_1_1: (x: Int)Unit m2_1_1()(1, 2, 3) ^ -Test_2.scala:44: error: macro applications do not support named and/or default arguments +Test_2.scala:44: error: not enough arguments for macro method m2_2_2: (x: Int, y: Int)Unit. +Unspecified value parameters x, y. m2_2_2()() ^ -Test_2.scala:45: error: macro applications do not support named and/or default arguments +Test_2.scala:45: error: not enough arguments for macro method m2_2_2: (x: Int, y: Int)Unit. +Unspecified value parameter y. m2_2_2()(1) ^ Test_2.scala:47: error: too many arguments for macro method m2_2_2: (x: Int, y: Int)Unit m2_2_2()(1, 2, 3) ^ -Test_2.scala:54: error: macro applications do not support named and/or default arguments +Test_2.scala:54: error: not enough arguments for macro method m2_1_inf: (x: Int, y: Int*)Unit. +Unspecified value parameters x, y. m2_1_inf()() ^ -Test_2.scala:59: error: macro applications do not support named and/or default arguments +Test_2.scala:59: error: not enough arguments for macro method m2_2_inf: (x: Int, y: Int, z: Int*)Unit. +Unspecified value parameters x, y, z. m2_2_inf()() ^ -Test_2.scala:60: error: macro applications do not support named and/or default arguments +Test_2.scala:60: error: not enough arguments for macro method m2_2_inf: (x: Int, y: Int, z: Int*)Unit. +Unspecified value parameters y, z. m2_2_inf()(1) ^ 24 errors found diff --git a/test/files/neg/t7602.check b/test/files/neg/t7602.check new file mode 100644 index 0000000000..5bb1450d7d --- /dev/null +++ b/test/files/neg/t7602.check @@ -0,0 +1,5 @@ +t7602.scala:16: error: method foo is defined twice + conflicting symbols both originated in file 't7602.scala' + def foo : Device + ^ +one error found diff --git a/test/files/neg/t7602.scala b/test/files/neg/t7602.scala new file mode 100644 index 0000000000..5a9444a1ab --- /dev/null +++ b/test/files/neg/t7602.scala @@ -0,0 +1,26 @@ +trait Table[T]{ + def foo : T +} +trait Computer +trait Device + +object schema{ + def lub[T]( a:T, b:T ) = ??? + lub(null:Computers,null:Devices) +} +trait Computers extends Table[Computer]{ + def foo : Computer +} +trait Devices extends Table[Device]{ + def foo : Device + def foo : Device +} +/* Was: +Exception in thread "main" java.lang.AssertionError: assertion failed: List(method foo, method foo) + at scala.Predef$.assert(Predef.scala:165) + at scala.reflect.internal.Symbols$Symbol.suchThat(Symbols.scala:1916) + at scala.reflect.internal.tpe.GlbLubs$$anonfun$23.apply(GlbLubs.scala:350) + at scala.reflect.internal.tpe.GlbLubs$$anonfun$23.apply(GlbLubs.scala:349) + at scala.collection.immutable.List.map(List.scala:272) + at scala.reflect.internal.tpe.GlbLubs$class.lubsym$1(GlbLubs.scala:349) +*/
\ No newline at end of file diff --git a/test/files/neg/t7623.check b/test/files/neg/t7623.check new file mode 100644 index 0000000000..db368dd369 --- /dev/null +++ b/test/files/neg/t7623.check @@ -0,0 +1,21 @@ +t7623.scala:19: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*). + def f = "" match { case X(s) => } + ^ +t7623.scala:21: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*). + def g = "" match { case X(s, t) => } + ^ +t7623.scala:23: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*). + def h = "" match { case X(s, t, u @ _*) => } + ^ +t7623.scala:9: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*). + def f = C("") match { case C(s) => } + ^ +t7623.scala:11: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*). + def g = C("") match { case C(s, t) => } + ^ +t7623.scala:13: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*). + def h = C("") match { case C(s, t, u @ _*) => } + ^ +error: No warnings can be incurred under -Xfatal-warnings. +6 warnings found +one error found diff --git a/test/files/neg/t7623.flags b/test/files/neg/t7623.flags new file mode 100644 index 0000000000..74c9e38323 --- /dev/null +++ b/test/files/neg/t7623.flags @@ -0,0 +1 @@ +-Xlint:stars-align -Xfatal-warnings diff --git a/test/files/neg/t7623.scala b/test/files/neg/t7623.scala new file mode 100644 index 0000000000..5c40f37bc1 --- /dev/null +++ b/test/files/neg/t7623.scala @@ -0,0 +1,38 @@ + + +case class C(s: String, xs: Int*) + +object X { def unapplySeq(a: Any): Option[(String, Seq[Int])] = Some("", List(1,2,3)) } + +// for case classes with varargs, avoid misaligned patterns +trait Ctest { + def f = C("") match { case C(s) => } + + def g = C("") match { case C(s, t) => } + + def h = C("") match { case C(s, t, u @ _*) => } + + def ok = C("") match { case C(s, u @ _*) => } +} +// for extractors that unapplySeq: Option[(Something, Seq[_])], avoid misaligned patterns +trait Xtest { + def f = "" match { case X(s) => } + + def g = "" match { case X(s, t) => } + + def h = "" match { case X(s, t, u @ _*) => } + + def ok = "" match { case X(s, u @ _*) => } +} +// for extractors that unapplySeq: Option[Seq[_]], anything goes +trait Rtest { + val r = "(a+)".r + + def f = "" match { case r(s) => } + + def g = "" match { case r(s, t) => } + + def h = "" match { case r(s, t, u @ _*) => } + + def whatever = "" match { case r(u @ _*) => } +} diff --git a/test/files/neg/t7636.check b/test/files/neg/t7636.check index f70d50bee3..12391cccc8 100644 --- a/test/files/neg/t7636.check +++ b/test/files/neg/t7636.check @@ -4,7 +4,7 @@ t7636.scala:3: error: illegal inheritance; ^ t7636.scala:3: error: type mismatch; found : Either[_$2,_$3(in constructor C)] where type _$3(in constructor C), type _$2 - required: Either[_, _$3(in object Main)] where type _$3(in object Main) + required: Either[_, _$3(in value <local Main>)] where type _$3(in value <local Main>) class C extends ResultTable(Left(5):Either[_,_])(5) ^ two errors found diff --git a/test/files/neg/t7848-interp-warn.check b/test/files/neg/t7848-interp-warn.check index b7df6d8ce2..637fc8941a 100644 --- a/test/files/neg/t7848-interp-warn.check +++ b/test/files/neg/t7848-interp-warn.check @@ -1,12 +1,15 @@ -t7848-interp-warn.scala:8: warning: `$foo` looks like an interpolated identifier! Did you forget the interpolator? +t7848-interp-warn.scala:8: warning: possible missing interpolator: detected interpolated identifier `$foo` "An important $foo message!" ^ -t7848-interp-warn.scala:12: warning: That looks like an interpolated expression! Did you forget the interpolator? +t7848-interp-warn.scala:12: warning: possible missing interpolator: detected an interpolated expression "A doubly important ${foo * 2} message!" ^ -t7848-interp-warn.scala:16: warning: `$bar` looks like an interpolated identifier! Did you forget the interpolator? +t7848-interp-warn.scala:15: warning: possible missing interpolator: detected interpolated identifier `$bar` + def i = s"Try using '${ "$bar" }' instead." // was: no warn on space test + ^ +t7848-interp-warn.scala:16: warning: possible missing interpolator: detected interpolated identifier `$bar` def j = s"Try using '${ "something like $bar" }' instead." // warn ^ error: No warnings can be incurred under -Xfatal-warnings. -three warnings found +four warnings found one error found diff --git a/test/files/neg/t7848-interp-warn.flags b/test/files/neg/t7848-interp-warn.flags index 7949c2afa2..b0d7bc25cb 100644 --- a/test/files/neg/t7848-interp-warn.flags +++ b/test/files/neg/t7848-interp-warn.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings +-Xlint:missing-interpolator -Xfatal-warnings diff --git a/test/files/neg/t7848-interp-warn.scala b/test/files/neg/t7848-interp-warn.scala index 3887aff8de..a76141041d 100644 --- a/test/files/neg/t7848-interp-warn.scala +++ b/test/files/neg/t7848-interp-warn.scala @@ -12,7 +12,7 @@ object Test { "A doubly important ${foo * 2} message!" } def h = s"Try using '$$bar' instead." // no warn - def i = s"Try using '${ "$bar" }' instead." // no warn on space test + def i = s"Try using '${ "$bar" }' instead." // was: no warn on space test def j = s"Try using '${ "something like $bar" }' instead." // warn def k = f"Try using '$bar' instead." // no warn on other std interps } diff --git a/test/files/neg/t8035-no-adapted-args.check b/test/files/neg/t8035-no-adapted-args.check new file mode 100644 index 0000000000..43637b2c1f --- /dev/null +++ b/test/files/neg/t8035-no-adapted-args.check @@ -0,0 +1,21 @@ +t8035-no-adapted-args.scala:4: warning: No automatic adaptation here: use explicit parentheses. + signature: Test.f[T](x: T): Int + given arguments: 1, 2, 3 + after adaptation: Test.f((1, 2, 3): (Int, Int, Int)) + f(1, 2, 3) + ^ +t8035-no-adapted-args.scala:4: error: too many arguments for method f: (x: (Int, Int, Int))Int + f(1, 2, 3) + ^ +t8035-no-adapted-args.scala:5: warning: No automatic adaptation here: use explicit parentheses. + signature: Test.f[T](x: T): Int + given arguments: <none> + after adaptation: Test.f((): Unit) + f() + ^ +t8035-no-adapted-args.scala:5: error: not enough arguments for method f: (x: Unit)Int. +Unspecified value parameter x. + f() + ^ +two warnings found +two errors found diff --git a/test/files/neg/t8035-no-adapted-args.flags b/test/files/neg/t8035-no-adapted-args.flags new file mode 100644 index 0000000000..b3e8c505e2 --- /dev/null +++ b/test/files/neg/t8035-no-adapted-args.flags @@ -0,0 +1 @@ +-Yno-adapted-args
\ No newline at end of file diff --git a/test/files/neg/t8035-no-adapted-args.scala b/test/files/neg/t8035-no-adapted-args.scala new file mode 100644 index 0000000000..82690ebe94 --- /dev/null +++ b/test/files/neg/t8035-no-adapted-args.scala @@ -0,0 +1,6 @@ +object Test { + def f[T](x: T) = 0 + + f(1, 2, 3) + f() +} diff --git a/test/files/neg/t8217-local-alias-requires-rhs.check b/test/files/neg/t8217-local-alias-requires-rhs.check new file mode 100644 index 0000000000..0d4f0864ba --- /dev/null +++ b/test/files/neg/t8217-local-alias-requires-rhs.check @@ -0,0 +1,10 @@ +t8217-local-alias-requires-rhs.scala:6: error: only classes can have declared but undefined members + type B + ^ +t8217-local-alias-requires-rhs.scala:3: error: only classes can have declared but undefined members + type A + ^ +t8217-local-alias-requires-rhs.scala:14: error: only classes can have declared but undefined members + def this(a: Any) = { this(); type C } + ^ +three errors found diff --git a/test/files/neg/t8217-local-alias-requires-rhs.scala b/test/files/neg/t8217-local-alias-requires-rhs.scala new file mode 100644 index 0000000000..12b7976835 --- /dev/null +++ b/test/files/neg/t8217-local-alias-requires-rhs.scala @@ -0,0 +1,15 @@ +trait Alias { + def foo = { + type A + } + val bar = { + type B + object O { + type OK + } + } +} + +class C { + def this(a: Any) = { this(); type C } +} diff --git a/test/files/neg/t8266-invalid-interp.check b/test/files/neg/t8266-invalid-interp.check index 70dd4081b0..bb2d44a80c 100644 --- a/test/files/neg/t8266-invalid-interp.check +++ b/test/files/neg/t8266-invalid-interp.check @@ -1,10 +1,10 @@ t8266-invalid-interp.scala:4: error: Trailing '\' escapes nothing. f"a\", ^ -t8266-invalid-interp.scala:5: error: invalid escape character at index 1 in "a\xc" +t8266-invalid-interp.scala:5: error: invalid escape '\x' not one of [\b, \t, \n, \f, \r, \\, \", \'] at index 1 in "a\xc". Use \\ for literal \. f"a\xc", ^ -t8266-invalid-interp.scala:7: error: invalid escape character at index 1 in "a\vc" +t8266-invalid-interp.scala:7: error: invalid escape '\v' not one of [\b, \t, \n, \f, \r, \\, \", \'] at index 1 in "a\vc". Use \\ for literal \. f"a\vc" ^ three errors found diff --git a/test/files/neg/t8291.check b/test/files/neg/t8291.check new file mode 100644 index 0000000000..c9972e5575 --- /dev/null +++ b/test/files/neg/t8291.check @@ -0,0 +1,7 @@ +t8291.scala:5: error: Could not find implicit for Int or String + implicitly[X[Int, String]] + ^ +t8291.scala:6: error: Could not find implicit for Int or String + implicitly[Z[String]] + ^ +two errors found diff --git a/test/files/neg/t8291.scala b/test/files/neg/t8291.scala new file mode 100644 index 0000000000..b344586a56 --- /dev/null +++ b/test/files/neg/t8291.scala @@ -0,0 +1,7 @@ +@scala.annotation.implicitNotFound("Could not find implicit for ${T} or ${U}") trait X[T, U] + +object Test { + type Z[U] = X[Int, U] + implicitly[X[Int, String]] + implicitly[Z[String]] +} diff --git a/test/files/neg/t8325-b.check b/test/files/neg/t8325-b.check new file mode 100644 index 0000000000..ec80826dc0 --- /dev/null +++ b/test/files/neg/t8325-b.check @@ -0,0 +1,10 @@ +t8325-b.scala:3: error: Unmatched closing brace '}' ignored here + def k(is: Int*} = ??? + ^ +t8325-b.scala:3: error: ';' expected but '=' found. + def k(is: Int*} = ??? + ^ +t8325-b.scala:4: error: eof expected but '}' found. +} +^ +three errors found diff --git a/test/files/neg/t8325-b.scala b/test/files/neg/t8325-b.scala new file mode 100644 index 0000000000..6ac78708bb --- /dev/null +++ b/test/files/neg/t8325-b.scala @@ -0,0 +1,4 @@ + +trait Test { + def k(is: Int*} = ??? +} diff --git a/test/files/neg/t8325-c.check b/test/files/neg/t8325-c.check new file mode 100644 index 0000000000..51ea4988a6 --- /dev/null +++ b/test/files/neg/t8325-c.check @@ -0,0 +1,7 @@ +t8325-c.scala:3: error: identifier expected but ')' found. + def k(xx: Int`*`) = ??? + ^ +t8325-c.scala:4: error: ')' expected but '}' found. +} +^ +two errors found diff --git a/test/files/neg/t8325-c.scala b/test/files/neg/t8325-c.scala new file mode 100644 index 0000000000..076202df3f --- /dev/null +++ b/test/files/neg/t8325-c.scala @@ -0,0 +1,4 @@ + +trait Test { + def k(xx: Int`*`) = ??? +} diff --git a/test/files/neg/t8325.check b/test/files/neg/t8325.check new file mode 100644 index 0000000000..175a0db415 --- /dev/null +++ b/test/files/neg/t8325.check @@ -0,0 +1,15 @@ +t8325.scala:5: error: *-parameter must come last + def f(is: Int*, s: String) = ??? + ^ +t8325.scala:7: error: *-parameter must come last + def h(is: Int * String *, s: String) = ??? + ^ +t8325.scala:10: error: type mismatch; + found : Int(5) + required: Int* + def j(is: Int* = 5) = ??? + ^ +t8325.scala:10: error: a parameter section with a `*'-parameter is not allowed to have default arguments + def j(is: Int* = 5) = ??? + ^ +four errors found diff --git a/test/files/neg/t8325.scala b/test/files/neg/t8325.scala new file mode 100644 index 0000000000..3813797e83 --- /dev/null +++ b/test/files/neg/t8325.scala @@ -0,0 +1,11 @@ + +trait Test { + type OK[A,B] = A Tuple2 B + type *[A,B] = A Tuple2 B + def f(is: Int*, s: String) = ??? + def g(is: Int * String, s: String) = ??? // OK + def h(is: Int * String *, s: String) = ??? + // won't recover from following + //def i(is: Int OK) = ??? //error: identifier expected but ')' found. + def j(is: Int* = 5) = ??? +} diff --git a/test/files/neg/t8430.check b/test/files/neg/t8430.check new file mode 100644 index 0000000000..dbc0c70bba --- /dev/null +++ b/test/files/neg/t8430.check @@ -0,0 +1,27 @@ +t8430.scala:15: warning: match may not be exhaustive. +It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + ^ +t8430.scala:16: warning: match may not be exhaustive. +It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + ^ +t8430.scala:17: warning: match may not be exhaustive. +It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + ^ +t8430.scala:18: warning: match may not be exhaustive. +It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + ^ +t8430.scala:19: warning: match may not be exhaustive. +It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + ^ +t8430.scala:20: warning: match may not be exhaustive. +It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + ^ +error: No warnings can be incurred under -Xfatal-warnings. +6 warnings found +one error found diff --git a/test/files/neg/t8430.flags b/test/files/neg/t8430.flags new file mode 100644 index 0000000000..6f60189a8d --- /dev/null +++ b/test/files/neg/t8430.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Ypatmat-exhaust-depth off diff --git a/test/files/neg/t8430.scala b/test/files/neg/t8430.scala new file mode 100644 index 0000000000..4166b08a0a --- /dev/null +++ b/test/files/neg/t8430.scala @@ -0,0 +1,32 @@ +sealed trait CL3Literal +case object IntLit extends CL3Literal +case object CharLit extends CL3Literal +case object BooleanLit extends CL3Literal +case object UnitLit extends CL3Literal + + +sealed trait Tree +case class LetL(value: CL3Literal) extends Tree +case object LetP extends Tree +case object LetC extends Tree +case object LetF extends Tree + +object Test { + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + (tree: Tree) => tree match {case LetL(CharLit) => ??? } + // After the first patch for SI-8430, we achieve stability: all of + // these get the same warning: + // + // ??, LetC, LetF, LetL(IntLit), LetP + // + // Before, it was non-deterministic. + // + // However, we our list of counter examples is itself non-exhaustive. + // We need to rework counter example generation to fix that. + // + // That work is the subject of SI-7746 +} diff --git a/test/files/neg/t845.check b/test/files/neg/t845.check deleted file mode 100644 index 07ed7e417b..0000000000 --- a/test/files/neg/t845.check +++ /dev/null @@ -1,4 +0,0 @@ -t845.scala:4: error: only classes can have declared but undefined members - type Bar; - ^ -one error found diff --git a/test/files/neg/t8450.check b/test/files/neg/t8450.check new file mode 100644 index 0000000000..eeabb9730c --- /dev/null +++ b/test/files/neg/t8450.check @@ -0,0 +1,6 @@ +t8450.scala:5: warning: implicit numeric widening + def elapsed: Foo = (System.nanoTime - 100L).foo + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t8450.flags b/test/files/neg/t8450.flags new file mode 100644 index 0000000000..9a1332d7af --- /dev/null +++ b/test/files/neg/t8450.flags @@ -0,0 +1 @@ +-Ywarn-numeric-widen -Xfatal-warnings
\ No newline at end of file diff --git a/test/files/neg/t8450.scala b/test/files/neg/t8450.scala new file mode 100644 index 0000000000..f20ed2bc31 --- /dev/null +++ b/test/files/neg/t8450.scala @@ -0,0 +1,12 @@ +trait Foo + +class WarnWidening { + implicit class FooDouble(d: Double) { def foo = new Foo {} } + def elapsed: Foo = (System.nanoTime - 100L).foo +} + +class NoWarnWidening { + implicit class FooLong(l: Long) { def foo = new Foo {} } + implicit class FooDouble(d: Double) { def foo = new Foo {} } + def elapsed: Foo = (System.nanoTime - 100L).foo +} diff --git a/test/files/neg/t8463.check b/test/files/neg/t8463.check new file mode 100644 index 0000000000..9aaacf8391 --- /dev/null +++ b/test/files/neg/t8463.check @@ -0,0 +1,27 @@ +t8463.scala:5: error: type mismatch; + found : Long + required: ?T[Long] +Note that implicit conversions are not applicable because they are ambiguous: + both method longWrapper in class LowPriorityImplicits of type (x: Long)scala.runtime.RichLong + and method ArrowAssoc in object Predef of type [A](self: A)ArrowAssoc[A] + are possible conversion functions from Long to ?T[Long] + insertCell(Foo(5)) + ^ +t8463.scala:5: error: no type parameters for method apply: (activity: T[Long])Test.Foo[T] in object Foo exist so that it can be applied to arguments (Long) + --- because --- +argument expression's type is not compatible with formal parameter type; + found : Long + required: ?T[Long] + insertCell(Foo(5)) + ^ +t8463.scala:5: error: type mismatch; + found : Long(5L) + required: T[Long] + insertCell(Foo(5)) + ^ +t8463.scala:5: error: type mismatch; + found : Test.Foo[T] + required: Test.Foo[Test.Cell] + insertCell(Foo(5)) + ^ +four errors found diff --git a/test/files/neg/t8463.scala b/test/files/neg/t8463.scala new file mode 100644 index 0000000000..7c954fd834 --- /dev/null +++ b/test/files/neg/t8463.scala @@ -0,0 +1,38 @@ +object Test { + case class Foo[+T[_]](activity:T[Long]) + type Cell[T] = T + def insertCell(u:Foo[Cell]) = ??? + insertCell(Foo(5)) +} + +/* If SI-8230 is fixed, and `viewExists` is changed to no longer leak + ambiguity errors, you might expect the check file for this test to + change as folloes: + +@@ -1,18 +1,10 @@ +-t8463.scala:5: error: no type parameters for method apply: (activity: +- --- because --- +-argument expression's type is not compatible with formal parameter ty ++t8463.scala:5: error: type mismatch; + found : Long + required: ?T[Long] ++Note that implicit conversions are not applicable because they are am ++ both method longWrapper in class LowPriorityImplicits of type (x: Lo ++ and method ArrowAssoc in object Predef of type [A](self: A)ArrowAsso ++ are possible conversion functions from Long to ?T[Long] + insertCell(Foo(5)) +- ^ +-t8463.scala:5: error: type mismatch; +- found : Long(5L) +- required: T[Long] +- insertCell(Foo(5)) +- ^ +-t8463.scala:5: error: type mismatch; +- found : Test.Foo[T] +- required: Test.Foo[Test.Cell] +- insertCell(Foo(5)) +- ^ +-three errors found ++ ^ ++one error found +*/ diff --git a/test/files/neg/t8525.check b/test/files/neg/t8525.check new file mode 100644 index 0000000000..5287e43b7a --- /dev/null +++ b/test/files/neg/t8525.check @@ -0,0 +1,15 @@ +t8525.scala:7: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. + signature: X.f(p: (Int, Int)): Int + given arguments: 3, 4 + after adaptation: X.f((3, 4): (Int, Int)) + def g = f(3, 4) // adapted + ^ +t8525.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. + override def toString = name // shadowing mutable var name + ^ +t8525.scala:8: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead + def u: Unit = () // unitarian universalist + ^ +error: No warnings can be incurred under -Xfatal-warnings. +three warnings found +one error found diff --git a/test/files/neg/t8525.flags b/test/files/neg/t8525.flags new file mode 100644 index 0000000000..53b2dfe7ec --- /dev/null +++ b/test/files/neg/t8525.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Xlint:-missing-interpolator -Xlint diff --git a/test/files/neg/t8525.scala b/test/files/neg/t8525.scala new file mode 100644 index 0000000000..7bed04904f --- /dev/null +++ b/test/files/neg/t8525.scala @@ -0,0 +1,10 @@ + +class Named(var name: String) + +class X(name: String) extends Named(name) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist + override def toString = name // shadowing mutable var name +} diff --git a/test/files/neg/t8534.check b/test/files/neg/t8534.check new file mode 100644 index 0000000000..297e7c1beb --- /dev/null +++ b/test/files/neg/t8534.check @@ -0,0 +1,4 @@ +t8534.scala:6: error: MyTrait is not an enclosing class + class BugTest {def isTheBugHere(in: MyTrait.this.type#SomeData) = false} + ^ +one error found diff --git a/test/files/neg/t8534.scala b/test/files/neg/t8534.scala new file mode 100644 index 0000000000..f118d22b82 --- /dev/null +++ b/test/files/neg/t8534.scala @@ -0,0 +1,7 @@ +object line1 { + trait MyTrait +} +object line2 { + import line2._ + class BugTest {def isTheBugHere(in: MyTrait.this.type#SomeData) = false} +} diff --git a/test/files/neg/t8534b.check b/test/files/neg/t8534b.check new file mode 100644 index 0000000000..39ffa41194 --- /dev/null +++ b/test/files/neg/t8534b.check @@ -0,0 +1,4 @@ +t8534b.scala:3: error: stable identifier required, but foo.type found. + type T = foo.type#Foo + ^ +one error found diff --git a/test/files/neg/t8534b.scala b/test/files/neg/t8534b.scala new file mode 100644 index 0000000000..73b6703a9c --- /dev/null +++ b/test/files/neg/t8534b.scala @@ -0,0 +1,4 @@ +object Test { + def foo = "" + type T = foo.type#Foo +} diff --git a/test/files/neg/t8597.check b/test/files/neg/t8597.check new file mode 100644 index 0000000000..bc945f9191 --- /dev/null +++ b/test/files/neg/t8597.check @@ -0,0 +1,21 @@ +t8597.scala:2: warning: abstract type T in type pattern Some[T] is unchecked since it is eliminated by erasure + def nowarn[T] = (null: Any) match { case _: Some[T] => } // warn (did not warn due to SI-8597) + ^ +t8597.scala:5: warning: abstract type pattern T is unchecked since it is eliminated by erasure + def warn1[T] = (null: Any) match { case _: T => } // warn + ^ +t8597.scala:6: warning: non-variable type argument String in type pattern Some[String] is unchecked since it is eliminated by erasure + def warn2 = (null: Any) match { case _: Some[String] => } // warn + ^ +t8597.scala:7: warning: non-variable type argument Unchecked.this.C in type pattern Some[Unchecked.this.C] is unchecked since it is eliminated by erasure + (null: Any) match { case _: Some[C] => } // warn + ^ +t8597.scala:18: warning: abstract type T in type pattern Array[T] is unchecked since it is eliminated by erasure + def warnArray[T] = (null: Any) match { case _: Array[T] => } // warn (did not warn due to SI-8597) + ^ +t8597.scala:26: warning: non-variable type argument String in type pattern Array[Array[List[String]]] is unchecked since it is eliminated by erasure + def warnArrayErasure2 = (null: Any) match {case Some(_: Array[Array[List[String]]]) => } // warn + ^ +error: No warnings can be incurred under -Xfatal-warnings. +6 warnings found +one error found diff --git a/test/files/pos/switch-small.flags b/test/files/neg/t8597.flags index 85d8eb2ba2..85d8eb2ba2 100644 --- a/test/files/pos/switch-small.flags +++ b/test/files/neg/t8597.flags diff --git a/test/files/neg/t8597.scala b/test/files/neg/t8597.scala new file mode 100644 index 0000000000..068e87d91a --- /dev/null +++ b/test/files/neg/t8597.scala @@ -0,0 +1,27 @@ +class Unchecked[C] { + def nowarn[T] = (null: Any) match { case _: Some[T] => } // warn (did not warn due to SI-8597) + + // These warned before. + def warn1[T] = (null: Any) match { case _: T => } // warn + def warn2 = (null: Any) match { case _: Some[String] => } // warn + (null: Any) match { case _: Some[C] => } // warn + + // These must remain without warnings. These are excerpts from + // related tests that are more exhauative. + class C; class D extends C + def okay = (List(new D) : Seq[D]) match { case _: List[C] => case _ => } // nowarn + class B2[A, B] + class A2[X] extends B2[X, String] + def okay2(x: A2[Int]) = x match { case _: B2[Int, _] => true } // nowarn + def okay3(x: A2[Int]) = x match { case _: B2[Int, typeVar] => true } // nowarn + + def warnArray[T] = (null: Any) match { case _: Array[T] => } // warn (did not warn due to SI-8597) + def nowarnArrayC = (null: Any) match { case _: Array[C] => } // nowarn + + def nowarnArrayTypeVar[T] = (null: Any) match { case _: Array[t] => } // nowarn + + def noWarnArrayErasure1 = (null: Any) match {case Some(_: Array[String]) => } // nowarn + def noWarnArrayErasure2 = (null: Any) match {case Some(_: Array[List[_]]) => } // nowarn + def noWarnArrayErasure3 = (null: Any) match {case Some(_: Array[Array[List[_]]]) => } // nowarn + def warnArrayErasure2 = (null: Any) match {case Some(_: Array[Array[List[String]]]) => } // warn +} diff --git a/test/files/neg/t8597b.check b/test/files/neg/t8597b.check new file mode 100644 index 0000000000..3c45a31337 --- /dev/null +++ b/test/files/neg/t8597b.check @@ -0,0 +1,6 @@ +t8597b.scala:18: warning: non-variable type argument T in type pattern Some[T] is unchecked since it is eliminated by erasure + case _: Some[T] => // warn + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t8597b.flags b/test/files/neg/t8597b.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/neg/t8597b.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/neg/t8597b.scala b/test/files/neg/t8597b.scala new file mode 100644 index 0000000000..b29d591cb1 --- /dev/null +++ b/test/files/neg/t8597b.scala @@ -0,0 +1,21 @@ +object Unchecked { + (null: Any) match { + case _: Some[t] => + + // t is a fresh pattern type variable, despite our attempts to + // backtick our way to the enclosing `t`. Under this interpretation, + // the absense of an unchecked warning is expected. + (null: Any) match { + case _: Some[t] => // no warn + } + (null: Any) match { + case _: Some[`t`] => // no warn + } + + // here we correctly issue an unchecked warning + type T = t + (null: Any) match { + case _: Some[T] => // warn + } + } +} diff --git a/test/files/neg/t8610-arg.check b/test/files/neg/t8610-arg.check new file mode 100644 index 0000000000..d6fe207119 --- /dev/null +++ b/test/files/neg/t8610-arg.check @@ -0,0 +1,6 @@ +t8610-arg.scala:8: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead + def u: Unit = () // unitarian universalist + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t8610-arg.flags b/test/files/neg/t8610-arg.flags new file mode 100644 index 0000000000..f331ba9383 --- /dev/null +++ b/test/files/neg/t8610-arg.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Xlint nullary-unit diff --git a/test/files/neg/t8610-arg.scala b/test/files/neg/t8610-arg.scala new file mode 100644 index 0000000000..7bed04904f --- /dev/null +++ b/test/files/neg/t8610-arg.scala @@ -0,0 +1,10 @@ + +class Named(var name: String) + +class X(name: String) extends Named(name) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist + override def toString = name // shadowing mutable var name +} diff --git a/test/files/neg/t8610.check b/test/files/neg/t8610.check new file mode 100644 index 0000000000..334a947549 --- /dev/null +++ b/test/files/neg/t8610.check @@ -0,0 +1,18 @@ +t8610.scala:5: warning: possible missing interpolator: detected interpolated identifier `$name` + def x = "Hi, $name" // missing interp + ^ +t8610.scala:7: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. + signature: X.f(p: (Int, Int)): Int + given arguments: 3, 4 + after adaptation: X.f((3, 4): (Int, Int)) + def g = f(3, 4) // adapted + ^ +t8610.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. + override def toString = name // shadowing mutable var name + ^ +t8610.scala:8: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead + def u: Unit = () // unitarian universalist + ^ +error: No warnings can be incurred under -Xfatal-warnings. +four warnings found +one error found diff --git a/test/files/neg/t8610.flags b/test/files/neg/t8610.flags new file mode 100644 index 0000000000..954eaba352 --- /dev/null +++ b/test/files/neg/t8610.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Xlint diff --git a/test/files/neg/t8610.scala b/test/files/neg/t8610.scala new file mode 100644 index 0000000000..7bed04904f --- /dev/null +++ b/test/files/neg/t8610.scala @@ -0,0 +1,10 @@ + +class Named(var name: String) + +class X(name: String) extends Named(name) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist + override def toString = name // shadowing mutable var name +} diff --git a/test/files/neg/t8630.check b/test/files/neg/t8630.check new file mode 100644 index 0000000000..98b084b153 --- /dev/null +++ b/test/files/neg/t8630.check @@ -0,0 +1,7 @@ +t8630.scala:1: error: '{' expected but 'abstract' found. +package bobsdelights abstract class Fruit( val name: String, val color: String ) object Fruits { object Apple extends Fruit("apple", "red") object Orange extends Fruit("orange", "orange") object Pear extends Fruit("pear", "yellowish") val menu = List(Apple, Orange, Pear) } + ^ +t8630.scala:1: error: '}' expected but eof found. +package bobsdelights abstract class Fruit( val name: String, val color: String ) object Fruits { object Apple extends Fruit("apple", "red") object Orange extends Fruit("orange", "orange") object Pear extends Fruit("pear", "yellowish") val menu = List(Apple, Orange, Pear) } + ^ +two errors found diff --git a/test/files/neg/t8630.scala b/test/files/neg/t8630.scala new file mode 100644 index 0000000000..ea25227452 --- /dev/null +++ b/test/files/neg/t8630.scala @@ -0,0 +1 @@ +package bobsdelights abstract class Fruit( val name: String, val color: String ) object Fruits { object Apple extends Fruit("apple", "red") object Orange extends Fruit("orange", "orange") object Pear extends Fruit("pear", "yellowish") val menu = List(Apple, Orange, Pear) }
\ No newline at end of file diff --git a/test/files/neg/t8675.check b/test/files/neg/t8675.check new file mode 100644 index 0000000000..4e44fba918 --- /dev/null +++ b/test/files/neg/t8675.check @@ -0,0 +1,11 @@ +t8675.scala:13: error: type mismatch; + found : Boolean(true) + required: String + a.update(0, x[A]({new isString(true)})) // !!! allowed + ^ +t8675.scala:22: error: type mismatch; + found : Boolean(true) + required: String + new X().m(x[A]({new isString(true)})) // !!! allowed + ^ +two errors found diff --git a/test/files/neg/t8675.scala b/test/files/neg/t8675.scala new file mode 100644 index 0000000000..ca9bb57ffa --- /dev/null +++ b/test/files/neg/t8675.scala @@ -0,0 +1,24 @@ +class A(s: String) { + def foo(x: A) = x +} + +class isString(s: String) + +class Test { + + def x[A](a: Any): A = ??? + + def test { + val a = Array[A]() + a.update(0, x[A]({new isString(true)})) // !!! allowed + + // boils down to + class X { + def m(p: Any) {} + } + implicit class XOps(x: X) { + def m(p: Any) {} + } + new X().m(x[A]({new isString(true)})) // !!! allowed + } +} diff --git a/test/files/neg/t8675b.check b/test/files/neg/t8675b.check new file mode 100644 index 0000000000..cb7ac8af59 --- /dev/null +++ b/test/files/neg/t8675b.check @@ -0,0 +1,6 @@ +t8675b.scala:19: error: missing parameter type for expanded function +The argument types of an anonymous function must be fully known. (SLS 8.5) +Expected type was: List[Test.Reportable1[?,?]] => Boolean + for (path: List[Any] <- (null : Engine1).asRequirement.pathsIncludingSelf.toList) { + ^ +one error found diff --git a/test/files/neg/t8675b.scala b/test/files/neg/t8675b.scala new file mode 100644 index 0000000000..2c5015b1d0 --- /dev/null +++ b/test/files/neg/t8675b.scala @@ -0,0 +1,22 @@ +object Test { + trait Engine1 + + implicit class EngineTools1[Params, R](e: Engine1) { + def asRequirement: Requirement1[Params, R] = ??? + } + trait Requirement1[Params, R] { + def pathsIncludingSelf: Traversable[List[Reportable1[Params, R]]] + } + trait Reportable1[Params, R] + + // "missing paramater type" error was swallowed in 2.11.0 leading to a crash + // in the backend. + // + // This error is itself a regression (or at least a change) in 2.11.0-M7, + // specifically in SI-7944. The type paramaters to the implicit view + // `EngineTools1` are undetermined, and are now treated as type variables + // in the expected type of the closure argument to `withFilter`. + for (path: List[Any] <- (null : Engine1).asRequirement.pathsIncludingSelf.toList) { + ??? + } +} diff --git a/test/files/neg/t8731.check b/test/files/neg/t8731.check new file mode 100644 index 0000000000..d47bd55b45 --- /dev/null +++ b/test/files/neg/t8731.check @@ -0,0 +1,6 @@ +t8731.scala:10: warning: could not emit switch for @switch annotated match + def g(x: Int) = (x: @annotation.switch) match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t8731.flags b/test/files/neg/t8731.flags new file mode 100644 index 0000000000..e8fb65d50c --- /dev/null +++ b/test/files/neg/t8731.flags @@ -0,0 +1 @@ +-Xfatal-warnings
\ No newline at end of file diff --git a/test/files/neg/t8731.scala b/test/files/neg/t8731.scala new file mode 100644 index 0000000000..d93fe706ad --- /dev/null +++ b/test/files/neg/t8731.scala @@ -0,0 +1,15 @@ +class C { + // not a compile-time constant due to return type + final val K: Int = 20 + + def f(x: Int) = (x: @annotation.switch) match { + case K => 0 + case 2 => 1 + } + + def g(x: Int) = (x: @annotation.switch) match { + case K => 0 + case 2 => 1 + case 3 => 2 + } +} diff --git a/test/files/neg/t8736-c.check b/test/files/neg/t8736-c.check new file mode 100644 index 0000000000..06b2228543 --- /dev/null +++ b/test/files/neg/t8736-c.check @@ -0,0 +1,11 @@ +t8736-c.scala:4: warning: higher-kinded type should be enabled +by making the implicit value scala.language.higherKinds visible. +This can be achieved by adding the import clause 'import scala.language.higherKinds' +or by setting the compiler option -language:higherKinds. +See the Scala docs for value scala.language.higherKinds for a discussion +why the feature should be explicitly enabled. + def hk[M[_]] = ??? + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t8736-c.flags b/test/files/neg/t8736-c.flags new file mode 100644 index 0000000000..fde5313c96 --- /dev/null +++ b/test/files/neg/t8736-c.flags @@ -0,0 +1 @@ +-feature -language:-higherKinds,_ -Xfatal-warnings diff --git a/test/files/neg/t8736-c.scala b/test/files/neg/t8736-c.scala new file mode 100644 index 0000000000..8432775ae1 --- /dev/null +++ b/test/files/neg/t8736-c.scala @@ -0,0 +1,7 @@ +// scalac: -feature -language:-higherKinds,_ -Xfatal-warnings +// showing that wildcard doesn't supersede explicit disablement +class X { + def hk[M[_]] = ??? + + implicit def imp(x: X): Int = x.hashCode +} diff --git a/test/files/neg/t8764.check b/test/files/neg/t8764.check new file mode 100644 index 0000000000..6d89ebe106 --- /dev/null +++ b/test/files/neg/t8764.check @@ -0,0 +1,6 @@ +t8764.scala:8: error: type mismatch; + found : AnyVal + required: Double + val d: Double = a.productElement(0) + ^ +one error found diff --git a/test/files/run/t5614.flags b/test/files/neg/t8764.flags index 48fd867160..48fd867160 100644 --- a/test/files/run/t5614.flags +++ b/test/files/neg/t8764.flags diff --git a/test/files/neg/t8764.scala b/test/files/neg/t8764.scala new file mode 100644 index 0000000000..dc5bfb0160 --- /dev/null +++ b/test/files/neg/t8764.scala @@ -0,0 +1,9 @@ +object Main { + + case class IntAndDouble(i: Int, d: Double) + + // a.productElement used to be Int => Double + // now: Int => AnyVal + val a = IntAndDouble(1, 5.0) + val d: Double = a.productElement(0) +} diff --git a/test/files/neg/t8841.check b/test/files/neg/t8841.check new file mode 100644 index 0000000000..ad525dc3f8 --- /dev/null +++ b/test/files/neg/t8841.check @@ -0,0 +1,9 @@ +t8841.scala:13: error: recursive value c needs type + val ambiguousName = c.ambiguousName + ^ +t8841.scala:12: warning: failed to determine if 'ambiguousName = ...' is a named argument or an assignment expression. +an explicit type is required for the definition mentioned in the error message above. + val c = new Cell(ambiguousName = Some("bla")) + ^ +one warning found +one error found diff --git a/test/files/neg/t8841.scala b/test/files/neg/t8841.scala new file mode 100644 index 0000000000..80430d997e --- /dev/null +++ b/test/files/neg/t8841.scala @@ -0,0 +1,15 @@ +class Cell(val ambiguousName: Option[String]) + +class Test { + def wrap(f: Any): Nothing = ??? + + wrap { + // the namer for these two ValDefs is created when typing the argument expression + // of wrap. This happens to be in a silent context (tryTypedApply). Therefore, the + // cyclic reference will not be thrown, but transformed into a NormalTypeError by + // `silent`. This requires different handling in NamesDefaults. + + val c = new Cell(ambiguousName = Some("bla")) + val ambiguousName = c.ambiguousName + } +} diff --git a/test/files/neg/t8869.check b/test/files/neg/t8869.check new file mode 100644 index 0000000000..40b8570f9f --- /dev/null +++ b/test/files/neg/t8869.check @@ -0,0 +1,7 @@ +t8869.scala:5: error: class Option takes type parameters + def value: TC[({type l1[x] = Option})#l1] = ??? // error not reported! + ^ +t8869.scala:7: error: class Option takes type parameters + type l2[x] = Option // error correctly reported + ^ +two errors found diff --git a/test/files/neg/t8869.scala b/test/files/neg/t8869.scala new file mode 100644 index 0000000000..0c7f0c9451 --- /dev/null +++ b/test/files/neg/t8869.scala @@ -0,0 +1,10 @@ +class TC[T[_]] { + def identity[A](a: T[A]): T[A] = a +} +object Test { + def value: TC[({type l1[x] = Option})#l1] = ??? // error not reported! + + type l2[x] = Option // error correctly reported + def value1: TC[l2] = ??? +} + diff --git a/test/files/neg/t8890.check b/test/files/neg/t8890.check new file mode 100644 index 0000000000..1b69d6cf30 --- /dev/null +++ b/test/files/neg/t8890.check @@ -0,0 +1,4 @@ +t8890.scala:6: error: not found: type Str + def bar(x: Str): Unit = ??? + ^ +one error found diff --git a/test/files/neg/t8890.scala b/test/files/neg/t8890.scala new file mode 100644 index 0000000000..cbdeb11d43 --- /dev/null +++ b/test/files/neg/t8890.scala @@ -0,0 +1,11 @@ +package foo + +class A { + /** The other */ + def bar(x: Int): Unit = ??? + def bar(x: Str): Unit = ??? +} + +class B { + (new A).bar(0) +}
\ No newline at end of file diff --git a/test/files/neg/t9008.check b/test/files/neg/t9008.check new file mode 100644 index 0000000000..c32bc41baf --- /dev/null +++ b/test/files/neg/t9008.check @@ -0,0 +1,4 @@ +t9008.scala:2: error: type M takes type parameters + def x: List[M forSome { type M[_] }] = ??? + ^ +one error found diff --git a/test/files/neg/t9008.scala b/test/files/neg/t9008.scala new file mode 100644 index 0000000000..c6a5389e42 --- /dev/null +++ b/test/files/neg/t9008.scala @@ -0,0 +1,3 @@ +object Test { + def x: List[M forSome { type M[_] }] = ??? +} diff --git a/test/files/neg/t9008b.check b/test/files/neg/t9008b.check new file mode 100644 index 0000000000..5e911fc138 --- /dev/null +++ b/test/files/neg/t9008b.check @@ -0,0 +1,4 @@ +t9008b.scala:2: error: type M takes type parameters + type T = M forSome { type M[_] } + ^ +one error found diff --git a/test/files/neg/t9008b.scala b/test/files/neg/t9008b.scala new file mode 100644 index 0000000000..58f9d0e8de --- /dev/null +++ b/test/files/neg/t9008b.scala @@ -0,0 +1,3 @@ +object Test { + type T = M forSome { type M[_] } +} diff --git a/test/files/neg/t9041.check b/test/files/neg/t9041.check new file mode 100644 index 0000000000..669e9434e0 --- /dev/null +++ b/test/files/neg/t9041.check @@ -0,0 +1,4 @@ +t9041.scala:11: error: could not find implicit value for parameter cellSetter: CellSetter[scala.math.BigDecimal] + def setCell(cell: Cell, data: math.BigDecimal) { cell.setCellValue(data) } + ^ +one error found diff --git a/test/files/neg/t9041.scala b/test/files/neg/t9041.scala new file mode 100644 index 0000000000..2bdef0d3ae --- /dev/null +++ b/test/files/neg/t9041.scala @@ -0,0 +1,17 @@ +// False negative test, requires overloading in Cell. + +trait Cell { def setCellValue(i: Int) = () ; def setCellValue(d: Double) = () } + +trait Nope { + def f = { + trait CellSetter[A] { + def setCell(cell: Cell, data: A): Unit + } + implicit val bigDecimalCellSetter = new CellSetter[math.BigDecimal]() { + def setCell(cell: Cell, data: math.BigDecimal) { cell.setCellValue(data) } + } + implicit class RichCell(cell: Cell) { + def setCellValue[A](data: A)(implicit cellSetter: CellSetter[A]) = cellSetter.setCell(cell, data) + } + } +} diff --git a/test/files/neg/t9093.check b/test/files/neg/t9093.check new file mode 100644 index 0000000000..085a433f0b --- /dev/null +++ b/test/files/neg/t9093.check @@ -0,0 +1,6 @@ +t9093.scala:3: error: polymorphic expression cannot be instantiated to expected type; + found : [C](f: C)Null + required: Unit + val x: Unit = apply2(0)/*(0)*/ + ^ +one error found diff --git a/test/files/neg/t9093.scala b/test/files/neg/t9093.scala new file mode 100644 index 0000000000..d9922ad70e --- /dev/null +++ b/test/files/neg/t9093.scala @@ -0,0 +1,5 @@ +object Main { + def apply2[C](fa: Any)(f: C) = null + val x: Unit = apply2(0)/*(0)*/ +} + diff --git a/test/files/neg/t9127.check b/test/files/neg/t9127.check new file mode 100644 index 0000000000..2ecf8af464 --- /dev/null +++ b/test/files/neg/t9127.check @@ -0,0 +1,12 @@ +t9127.scala:4: warning: possible missing interpolator: detected interpolated identifier `$s` + val t = "$s" + ^ +t9127.scala:5: warning: possible missing interpolator: detected an interpolated expression + val u = "a${s}b" + ^ +t9127.scala:6: warning: possible missing interpolator: detected interpolated identifier `$s` + val v = "a$s b" + ^ +error: No warnings can be incurred under -Xfatal-warnings. +three warnings found +one error found diff --git a/test/files/neg/t9127.flags b/test/files/neg/t9127.flags new file mode 100644 index 0000000000..b0d7bc25cb --- /dev/null +++ b/test/files/neg/t9127.flags @@ -0,0 +1 @@ +-Xlint:missing-interpolator -Xfatal-warnings diff --git a/test/files/neg/t9127.scala b/test/files/neg/t9127.scala new file mode 100644 index 0000000000..c0746144eb --- /dev/null +++ b/test/files/neg/t9127.scala @@ -0,0 +1,7 @@ + +trait X { + val s = "hello" + val t = "$s" + val u = "a${s}b" + val v = "a$s b" +} diff --git a/test/files/neg/t9231.check b/test/files/neg/t9231.check new file mode 100644 index 0000000000..43c14f53ca --- /dev/null +++ b/test/files/neg/t9231.check @@ -0,0 +1,4 @@ +t9231.scala:8: error: not found: type DoesNotExist + foo[DoesNotExist] + ^ +one error found diff --git a/test/files/neg/t9231.scala b/test/files/neg/t9231.scala new file mode 100644 index 0000000000..05b1d24e9a --- /dev/null +++ b/test/files/neg/t9231.scala @@ -0,0 +1,9 @@ +class M[A] +class C { + implicit def M1: M[Int] = null + implicit def M2: M[String] = null + + def foo[A](implicit M: M[A]) = null + + foo[DoesNotExist] +} diff --git a/test/files/neg/t9273.check b/test/files/neg/t9273.check new file mode 100644 index 0000000000..1dca63a736 --- /dev/null +++ b/test/files/neg/t9273.check @@ -0,0 +1,10 @@ +t9273.scala:2: error: class type required but ? found + val foo: Class[_] = classOf // error without position, line or file + ^ +t9273.scala:3: error: not found: type X + val foo1: Class[_] = classOf[X] // good error, all info contained + ^ +t9273.scala:7: error: not found: type X + val foo4: Class[_] = Predef.classOf[X] // good error, all info contained + ^ +three errors found diff --git a/test/files/neg/t9273.scala b/test/files/neg/t9273.scala new file mode 100644 index 0000000000..3f99dff17f --- /dev/null +++ b/test/files/neg/t9273.scala @@ -0,0 +1,9 @@ +class MissingLineNumbers { + val foo: Class[_] = classOf // error without position, line or file + val foo1: Class[_] = classOf[X] // good error, all info contained + val foo2 = classOf // Infers T=Nothing + + val foo3: Class[_] = Predef.classOf // Infers T=Nothing. Irregular wrt typedIdent. + val foo4: Class[_] = Predef.classOf[X] // good error, all info contained + val foo5 = Predef.classOf // Infers T=Nothing +} diff --git a/test/files/neg/t963.check b/test/files/neg/t963.check index 4dc202c7bd..483e53c77d 100644 --- a/test/files/neg/t963.check +++ b/test/files/neg/t963.check @@ -1,9 +1,9 @@ -t963.scala:14: error: stable identifier required, but Test.this.y3.x found. +t963.scala:14: error: stable identifier required, but y3.x.type found. val w3 : y3.x.type = y3.x - ^ -t963.scala:17: error: stable identifier required, but Test.this.y4.x found. + ^ +t963.scala:17: error: stable identifier required, but y4.x.type found. val w4 : y4.x.type = y4.x - ^ + ^ t963.scala:10: error: type mismatch; found : AnyRef{def x: Integer} required: AnyRef{val x: Integer} diff --git a/test/files/neg/tailrec-4.check b/test/files/neg/tailrec-4.check new file mode 100644 index 0000000000..3ec3274478 --- /dev/null +++ b/test/files/neg/tailrec-4.check @@ -0,0 +1,16 @@ +tailrec-4.scala:6: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:11: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:17: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:23: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:31: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +5 errors found diff --git a/test/files/neg/tailrec-4.scala b/test/files/neg/tailrec-4.scala new file mode 100644 index 0000000000..4822799dfa --- /dev/null +++ b/test/files/neg/tailrec-4.scala @@ -0,0 +1,35 @@ +import annotation._ + +object Tail { + def tcInFunc: Unit = { + () => { + @tailrec def foo: Int = foo + 1 + } + } + def tcInBooleanExprFirstOp(x: Int, v: Int): Boolean = { + { + @tailrec def foo: Int = foo + 1 + foo + } == v && true + } + def tcInBooleanExprSecondOp(x: Int, v: Int): Boolean = { + true && { + @tailrec def foo: Int = foo + 1 + foo + } == v + } + def tcInIfCond(x: Int, v: Int): Boolean = { + if ({ + @tailrec def foo: Int = foo + 1 + foo + } == v) true else false + } + def tcInPatternGuard(x: Int, v: Int): Boolean = + v match { + case _ if + { + @tailrec def foo: Int = foo + 1 + foo == 42 + } => true + } +} diff --git a/test/files/neg/unchecked-abstract.check b/test/files/neg/unchecked-abstract.check index 72019082ac..703929dca8 100644 --- a/test/files/neg/unchecked-abstract.check +++ b/test/files/neg/unchecked-abstract.check @@ -4,6 +4,9 @@ unchecked-abstract.scala:16: warning: abstract type H in type Contravariant[M.th unchecked-abstract.scala:21: warning: abstract type H in type Contravariant[M.this.H] is unchecked since it is eliminated by erasure /* warn */ println(x.isInstanceOf[Contravariant[H]]) ^ +unchecked-abstract.scala:22: warning: abstract type T in type Contravariant[M.this.T] is unchecked since it is eliminated by erasure + /* warn */ println(x.isInstanceOf[Contravariant[T]]) + ^ unchecked-abstract.scala:27: warning: abstract type T in type Invariant[M.this.T] is unchecked since it is eliminated by erasure /* warn */ println(x.isInstanceOf[Invariant[T]]) ^ @@ -22,6 +25,15 @@ unchecked-abstract.scala:36: warning: abstract type H in type Invariant[M.this.H unchecked-abstract.scala:37: warning: abstract type T in type Invariant[M.this.T] is unchecked since it is eliminated by erasure /* warn */ println(x.isInstanceOf[Invariant[T]]) ^ +unchecked-abstract.scala:42: warning: abstract type T in type Covariant[M.this.T] is unchecked since it is eliminated by erasure + /* warn */ println(x.isInstanceOf[Covariant[T]]) + ^ +unchecked-abstract.scala:43: warning: abstract type L in type Covariant[M.this.L] is unchecked since it is eliminated by erasure + /* warn */ println(x.isInstanceOf[Covariant[L]]) + ^ +unchecked-abstract.scala:48: warning: abstract type L in type Covariant[M.this.L] is unchecked since it is eliminated by erasure + /* warn */ println(x.isInstanceOf[Covariant[L]]) + ^ error: No warnings can be incurred under -Xfatal-warnings. -8 warnings found +12 warnings found one error found diff --git a/test/files/neg/unchecked-refinement.check b/test/files/neg/unchecked-refinement.check index e85a51f44d..0bb944621b 100644 --- a/test/files/neg/unchecked-refinement.check +++ b/test/files/neg/unchecked-refinement.check @@ -10,6 +10,7 @@ unchecked-refinement.scala:23: warning: a pattern match on a refinement type is unchecked-refinement.scala:24: warning: a pattern match on a refinement type is unchecked /* nowarn - todo */ case x: AnyRef { def size: Int } if b => x.size // this could/should do a static conformance test and not warn ^ +warning: there was one feature warning; re-run with -feature for details error: No warnings can be incurred under -Xfatal-warnings. -four warnings found +5 warnings found one error found diff --git a/test/files/neg/virtpatmat_exhaust_big.check b/test/files/neg/virtpatmat_exhaust_big.check new file mode 100644 index 0000000000..fddc85a362 --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_big.check @@ -0,0 +1,7 @@ +virtpatmat_exhaust_big.scala:27: warning: match may not be exhaustive. +It would fail on the following input: Z11() + def foo(z: Z) = z match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/virtpatmat_exhaust_big.flags b/test/files/neg/virtpatmat_exhaust_big.flags new file mode 100644 index 0000000000..b5a8748652 --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_big.flags @@ -0,0 +1 @@ +-Xfatal-warnings -unchecked diff --git a/test/files/neg/virtpatmat_exhaust_big.scala b/test/files/neg/virtpatmat_exhaust_big.scala new file mode 100644 index 0000000000..dd639eb56e --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_big.scala @@ -0,0 +1,32 @@ +sealed abstract class Z +object Z { + object Z0 extends Z + case class Z1() extends Z + object Z2 extends Z + case class Z3() extends Z + object Z4 extends Z + case class Z5() extends Z + object Z6 extends Z + case class Z7() extends Z + object Z8 extends Z + case class Z9() extends Z + object Z10 extends Z + case class Z11() extends Z + object Z12 extends Z + case class Z13() extends Z + object Z14 extends Z + case class Z15() extends Z + object Z16 extends Z + case class Z17() extends Z + object Z18 extends Z + case class Z19() extends Z +} + +object Test { + import Z._ + def foo(z: Z) = z match { + case Z0 | Z1() | Z2 | Z3() | Z4 | Z5() | Z6 | Z7() | Z8 | Z9() | + Z10 | Z12 | Z13() | Z14 | Z15() | Z16 | Z17() | Z18 | Z19() + => + } +} diff --git a/test/files/neg/virtpatmat_exhaust_compound.check b/test/files/neg/virtpatmat_exhaust_compound.check new file mode 100644 index 0000000000..72e0340682 --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_compound.check @@ -0,0 +1,15 @@ +virtpatmat_exhaust_compound.scala:14: warning: match may not be exhaustive. +It would fail on the following inputs: O1, O2, O4 + a match { + ^ +virtpatmat_exhaust_compound.scala:18: warning: match may not be exhaustive. +It would fail on the following input: O4 + def t1(a: Product with Base with Base2) = a match { + ^ +virtpatmat_exhaust_compound.scala:22: warning: match may not be exhaustive. +It would fail on the following input: O2 + def t2(a: Product with Base { def foo: Int }) = a match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +three warnings found +one error found diff --git a/test/files/neg/virtpatmat_exhaust_compound.flags b/test/files/neg/virtpatmat_exhaust_compound.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_compound.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/neg/virtpatmat_exhaust_compound.scala b/test/files/neg/virtpatmat_exhaust_compound.scala new file mode 100644 index 0000000000..386c7af98d --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_compound.scala @@ -0,0 +1,29 @@ +sealed trait Base +case object O1 extends Base +case object O2 extends Base { + def foo: Int = 0 +} + +sealed trait Base2 +case object O3 extends Base2 + +case object O4 extends Base with Base2 + +object Test { + val a /*: Product with Serialiable with Base */ = if (true) O1 else O2 + a match { + case null => + } + + def t1(a: Product with Base with Base2) = a match { + case null => // O1..O3 should *not* be possible here + } + + def t2(a: Product with Base { def foo: Int }) = a match { + case null => // O2 in the domain + } + + def t3(a: Product with Base { def bar: Int }) = a match { + case null => // nothing in the domain + } +} diff --git a/test/files/neg/warn-inferred-any.check b/test/files/neg/warn-inferred-any.check index 4628033e55..8ad81d1529 100644 --- a/test/files/neg/warn-inferred-any.check +++ b/test/files/neg/warn-inferred-any.check @@ -7,6 +7,9 @@ warn-inferred-any.scala:16: warning: a type was inferred to be `AnyVal`; this ma warn-inferred-any.scala:17: warning: a type was inferred to be `AnyVal`; this may indicate a programming error. { 1l to 5l contains 5d } ^ +warn-inferred-any.scala:25: warning: a type was inferred to be `Any`; this may indicate a programming error. + def za = f(1, "one") + ^ error: No warnings can be incurred under -Xfatal-warnings. -three warnings found +four warnings found one error found diff --git a/test/files/neg/warn-inferred-any.flags b/test/files/neg/warn-inferred-any.flags index a3127d392a..b580dfbbe3 100644 --- a/test/files/neg/warn-inferred-any.flags +++ b/test/files/neg/warn-inferred-any.flags @@ -1 +1 @@ --Xfatal-warnings -Ywarn-infer-any +-Xfatal-warnings -Xlint:infer-any diff --git a/test/files/neg/warn-inferred-any.scala b/test/files/neg/warn-inferred-any.scala index b853e6e5a8..693c33e7be 100644 --- a/test/files/neg/warn-inferred-any.scala +++ b/test/files/neg/warn-inferred-any.scala @@ -17,3 +17,11 @@ trait Ys[+A] { { 1l to 5l contains 5d } { 1l to 5l contains 5l } } + +trait Zs { + def f[A](a: A*) = 42 + def g[A >: Any](a: A*) = 42 // don't warn + + def za = f(1, "one") + def zu = g(1, "one") +} diff --git a/test/files/neg/warn-unused-privates.check b/test/files/neg/warn-unused-privates.check index d012869c93..4876ed8fc2 100644 --- a/test/files/neg/warn-unused-privates.check +++ b/test/files/neg/warn-unused-privates.check @@ -10,57 +10,60 @@ warn-unused-privates.scala:6: warning: private val in class Bippy is never used warn-unused-privates.scala:13: warning: private val in object Bippy is never used private val HEY_INSTANCE: Int = 1000 // warn ^ -warn-unused-privates.scala:35: warning: private val in class Boppy is never used +warn-unused-privates.scala:14: warning: private val in object Bippy is never used + private lazy val BOOL: Boolean = true // warn + ^ +warn-unused-privates.scala:36: warning: private val in class Boppy is never used private val hummer = "def" // warn ^ -warn-unused-privates.scala:42: warning: private var in trait Accessors is never used +warn-unused-privates.scala:43: warning: private var in trait Accessors is never used private var v1: Int = 0 // warn ^ -warn-unused-privates.scala:42: warning: private setter in trait Accessors is never used +warn-unused-privates.scala:43: warning: private setter in trait Accessors is never used private var v1: Int = 0 // warn ^ -warn-unused-privates.scala:43: warning: private setter in trait Accessors is never used +warn-unused-privates.scala:44: warning: private setter in trait Accessors is never used private var v2: Int = 0 // warn, never set ^ -warn-unused-privates.scala:44: warning: private var in trait Accessors is never used +warn-unused-privates.scala:45: warning: private var in trait Accessors is never used private var v3: Int = 0 // warn, never got ^ -warn-unused-privates.scala:56: warning: private default argument in trait DefaultArgs is never used +warn-unused-privates.scala:57: warning: private default argument in trait DefaultArgs is never used private def bippy(x1: Int, x2: Int = 10, x3: Int = 15): Int = x1 + x2 + x3 ^ -warn-unused-privates.scala:56: warning: private default argument in trait DefaultArgs is never used +warn-unused-privates.scala:57: warning: private default argument in trait DefaultArgs is never used private def bippy(x1: Int, x2: Int = 10, x3: Int = 15): Int = x1 + x2 + x3 ^ -warn-unused-privates.scala:67: warning: local var in method f0 is never used +warn-unused-privates.scala:68: warning: local var in method f0 is never used var x = 1 // warn ^ -warn-unused-privates.scala:74: warning: local val in method f1 is never used +warn-unused-privates.scala:75: warning: local val in method f1 is never used val b = new Outer // warn ^ -warn-unused-privates.scala:84: warning: private object in object Types is never used +warn-unused-privates.scala:85: warning: private object in object Types is never used private object Dongo { def f = this } // warn ^ -warn-unused-privates.scala:94: warning: local object in method l1 is never used +warn-unused-privates.scala:95: warning: local object in method l1 is never used object HiObject { def f = this } // warn ^ -warn-unused-privates.scala:78: warning: local var x in method f2 is never set - it could be a val +warn-unused-privates.scala:79: warning: local var x in method f2 is never set - it could be a val var x = 100 // warn about it being a var ^ -warn-unused-privates.scala:85: warning: private class Bar1 in object Types is never used +warn-unused-privates.scala:86: warning: private class Bar1 in object Types is never used private class Bar1 // warn ^ -warn-unused-privates.scala:87: warning: private type Alias1 in object Types is never used +warn-unused-privates.scala:88: warning: private type Alias1 in object Types is never used private type Alias1 = String // warn ^ -warn-unused-privates.scala:95: warning: local class Hi is never used +warn-unused-privates.scala:96: warning: local class Hi is never used class Hi { // warn ^ -warn-unused-privates.scala:99: warning: local class DingDongDoobie is never used +warn-unused-privates.scala:100: warning: local class DingDongDoobie is never used class DingDongDoobie // warn ^ -warn-unused-privates.scala:102: warning: local type OtherThing is never used +warn-unused-privates.scala:103: warning: local type OtherThing is never used type OtherThing = String // warn ^ error: No warnings can be incurred under -Xfatal-warnings. -21 warnings found +22 warnings found one error found diff --git a/test/files/neg/warn-unused-privates.scala b/test/files/neg/warn-unused-privates.scala index cb6e946a34..2faa07e759 100644 --- a/test/files/neg/warn-unused-privates.scala +++ b/test/files/neg/warn-unused-privates.scala @@ -11,6 +11,7 @@ object Bippy { def hi(x: Bippy) = x.HI_COMPANION private val HI_INSTANCE: Int = 500 // no warn, accessed from instance private val HEY_INSTANCE: Int = 1000 // warn + private lazy val BOOL: Boolean = true // warn } class A(val msg: String) diff --git a/test/files/pos/dotless-targs.flags b/test/files/pos/dotless-targs.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/pos/dotless-targs.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/pos/five-dot-f.flags b/test/files/pos/five-dot-f.flags deleted file mode 100644 index 112fc720a0..0000000000 --- a/test/files/pos/five-dot-f.flags +++ /dev/null @@ -1 +0,0 @@ --Xfuture
\ No newline at end of file diff --git a/test/files/pos/jesper.scala b/test/files/pos/jesper.scala new file mode 100644 index 0000000000..82623e4a24 --- /dev/null +++ b/test/files/pos/jesper.scala @@ -0,0 +1,30 @@ +object Pair { + sealed trait Pair { + type First + type Second <: Pair + } + + case class End() extends Pair { + type First = Nothing + type Second = End + + def ::[T](v : T) : Cons[T, End] = Cons(v, this) + } + + object End extends End() + + final case class Cons[T1, T2 <: Pair](_1 : T1, _2 : T2) extends Pair { + type First = T1 + type Second = T2 + + def ::[T](v : T) : Cons[T, Cons[T1, T2]] = Cons(v, this) + def find[T](implicit finder : Cons[T1, T2] => T) = finder(this) + } + + implicit def findFirst[T1, T2 <: Pair] : Cons[T1, T2] => T1 = (p : Cons[T1, T2]) => p._1 + implicit def findSecond[T, T1, T2 <: Pair](implicit finder : T2 => T) : Cons[T1, T2] => T = (p : Cons[T1, T2]) => finder(p._2) + + val p : Cons[Int, Cons[Boolean, End]] = 10 :: false :: End +// val x : Boolean = p.find[Boolean](findSecond(findFirst)) + val x2 : Boolean = p.find[Boolean] // Doesn't compile +} diff --git a/test/files/pos/macro-attachments/Macros_1.scala b/test/files/pos/macro-attachments/Macros_1.scala new file mode 100644 index 0000000000..38d05d5b85 --- /dev/null +++ b/test/files/pos/macro-attachments/Macros_1.scala @@ -0,0 +1,19 @@ +import scala.language.experimental.macros +import scala.reflect.macros.whitebox.Context + +trait Base +class Att extends Base + +object Macros { + def impl(c: Context) = { + import c.universe._ + import c.internal._ + import decorators._ + val dummy = q"x" + dummy.updateAttachment(new Att) + if (dummy.attachments.get[Base].isEmpty) c.abort(c.enclosingPosition, "that's not good") + q"()" + } + + def foo: Any = macro impl +}
\ No newline at end of file diff --git a/test/files/pos/macro-attachments/Test_2.scala b/test/files/pos/macro-attachments/Test_2.scala new file mode 100644 index 0000000000..acfddae942 --- /dev/null +++ b/test/files/pos/macro-attachments/Test_2.scala @@ -0,0 +1,3 @@ +object Test extends App { + Macros.foo +}
\ No newline at end of file diff --git a/test/files/pos/patmat-suppress.flags b/test/files/pos/patmat-suppress.flags new file mode 100644 index 0000000000..a988a5b807 --- /dev/null +++ b/test/files/pos/patmat-suppress.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Xno-patmat-analysis
\ No newline at end of file diff --git a/test/files/pos/patmat-suppress.scala b/test/files/pos/patmat-suppress.scala new file mode 100644 index 0000000000..7c8aded690 --- /dev/null +++ b/test/files/pos/patmat-suppress.scala @@ -0,0 +1,159 @@ +// test that none of these warn due to -Xno-patmat-analysis +// tests taken from test/files/neg/patmatexhaust.scala, test/files/neg/pat_unreachable.scala +class TestSealedExhaustive { // compile only + sealed abstract class Foo + + case class Bar(x:Int) extends Foo + case object Baz extends Foo + + def ma1(x:Foo) = x match { + case Bar(_) => // not exhaustive + } + + def ma2(x:Foo) = x match { + case Baz => // not exhaustive + } + + sealed abstract class Mult + case class Kult(s:Mult) extends Mult + case class Qult() extends Mult + + def ma33(x:Kult) = x match { // exhaustive + case Kult(_) => // exhaustive + } + + def ma3(x:Mult) = (x,x) match { // not exhaustive + case (Kult(_), Qult()) => // Kult missing + //case (Kult(_), Kult(_)) => + case (Qult(), Kult(_)) => // Qult missing + //case (Qult(), Qult()) => + } + + def ma3u(x:Mult) = ((x,x) : @unchecked) match { // not exhaustive, but not checked! + case (Kult(_), Qult()) => + case (Qult(), Kult(_)) => + } + + sealed abstract class Deep + + case object Ga extends Deep + sealed class Gp extends Deep + case object Gu extends Gp + + def zma3(x:Deep) = x match { // exhaustive! + case _ => + } + def zma4(x:Deep) = x match { // exhaustive! + case Ga => + case _ => + } + + def ma4(x:Deep) = x match { // missing cases: Gu, Gp which is not abstract so must be included + case Ga => + } + + def ma5(x:Deep) = x match { + case Gu => + case _ if 1 == 0 => + case Ga => + } + + def ma6() = List(1,2) match { // give up + case List(1,2) => + case x :: xs => + } + + def ma7() = List(1,2) match { //exhaustive + case 1::2::Nil => + case _ => + } + + sealed class B + case class B1() extends B + case object B2 extends B + def ma8(x: B) = x match { + case _: B => true + } + def ma9(x: B) = x match { + case B1() => true // missing B, which is not abstract so must be included + case B2 => true + } + + object ob1 { + sealed abstract class C + sealed abstract class C1 extends C + object C2 extends C + case class C3() extends C + case object C4 extends C + + def ma10(x: C) = x match { // exhaustive: abstract sealed C1 is dead end. + case C3() => true + case C2 | C4 => true + } + } + + object ob2 { + sealed abstract class C + abstract class C1 extends C + object C2 extends C + case class C3() extends C + case object C4 extends C + + def ma10(x: C) = x match { // not exhaustive: C1 is not sealed. + case C3() => true + case C2 | C4 => true + } + } + object ob3 { + sealed abstract class C + sealed abstract class C1 extends C + object D1 extends C1 + case class D2() extends C1 + object C2 extends C + case class C3() extends C + case object C4 extends C + + def ma10(x: C) = x match { // not exhaustive: C1 has subclasses. + case C3() => true + case C2 | C4 => true + } + } + object ob4 { + sealed abstract class C + sealed class C1 extends C + object C2 extends C + case class C3() extends C + case object C4 extends C + + def ma10(x: C) = x match { // not exhaustive: C1 is not abstract. + case C3() => true + case C2 | C4 => true + } + } +} + +object TestUnreachable extends App { + def unreachable1(xs:Seq[Char]) = xs match { + case Seq(x, y, _*) => x::y::Nil + case Seq(x, y, z, w) => List(z,w) // redundant! + } + def unreachable2(xs:Seq[Char]) = xs match { + case Seq(x, y, _*) => x::y::Nil + case Seq(x, y) => List(x, y) + } + + def not_unreachable(xs:Seq[Char]) = xs match { + case Seq(x, y, _*) => x::y::Nil + case Seq(x) => List(x) + } + def not_unreachable2(xs:Seq[Char]) = xs match { + case Seq(x, y) => x::y::Nil + case Seq(x, y, z, _*) => List(x,y) + } + + def contrivedExample[A, B, C](a: A, b: B, c: C): Unit = a match { + case b => println("matched b") + case c => println("matched c") + case _ => println("matched neither") + } +} diff --git a/test/files/pos/sammy_exist.flags b/test/files/pos/sammy_exist.flags new file mode 100644 index 0000000000..48fd867160 --- /dev/null +++ b/test/files/pos/sammy_exist.flags @@ -0,0 +1 @@ +-Xexperimental diff --git a/test/files/pos/sammy_exist.scala b/test/files/pos/sammy_exist.scala new file mode 100644 index 0000000000..f05ae20463 --- /dev/null +++ b/test/files/pos/sammy_exist.scala @@ -0,0 +1,17 @@ +// scala> typeOf[java.util.stream.Stream[_]].nonPrivateMember(TermName("map")).info +// [R](x$1: java.util.function.Function[_ >: T, _ <: R])java.util.stream.Stream[R] + +// java.util.function.Function +trait Fun[A, B] { def apply(x: A): B } + +// java.util.stream.Stream +class S[T](x: T) { def map[R](f: Fun[_ >: T, _ <: R]): R = f(x) } + +class Bla { def foo: Bla = this } + +// NOTE: inferred types show unmoored skolems, should pack them to display properly as bounded wildcards +object T { + val aBlaSAM = (new S(new Bla)).map(_.foo) + val fun: Fun[Bla, Bla] = (x: Bla) => x + val aBlaSAMX = (new S(new Bla)).map(fun) +} diff --git a/test/files/pos/sammy_overload.flags b/test/files/pos/sammy_overload.flags new file mode 100644 index 0000000000..48fd867160 --- /dev/null +++ b/test/files/pos/sammy_overload.flags @@ -0,0 +1 @@ +-Xexperimental diff --git a/test/files/pos/sammy_overload.scala b/test/files/pos/sammy_overload.scala new file mode 100644 index 0000000000..5472248f4d --- /dev/null +++ b/test/files/pos/sammy_overload.scala @@ -0,0 +1,9 @@ +trait Consumer[T] { + def consume(x: T): Unit +} + +object Test { + def foo(x: String): Unit = ??? + def foo(): Unit = ??? + val f: Consumer[_ >: String] = foo +}
\ No newline at end of file diff --git a/test/files/pos/sammy_override.flags b/test/files/pos/sammy_override.flags new file mode 100644 index 0000000000..48fd867160 --- /dev/null +++ b/test/files/pos/sammy_override.flags @@ -0,0 +1 @@ +-Xexperimental diff --git a/test/files/pos/sammy_override.scala b/test/files/pos/sammy_override.scala new file mode 100644 index 0000000000..a1d0651c39 --- /dev/null +++ b/test/files/pos/sammy_override.scala @@ -0,0 +1,8 @@ +trait IntConsumer { + def consume(x: Int): Unit +} + +object Test { + def anyConsumer(x: Any): Unit = ??? + val f: IntConsumer = anyConsumer +}
\ No newline at end of file diff --git a/test/files/pos/switch-small.scala b/test/files/pos/switch-small.scala deleted file mode 100644 index 9de9ca028e..0000000000 --- a/test/files/pos/switch-small.scala +++ /dev/null @@ -1,8 +0,0 @@ -import annotation._ - -object Test { - def f(x: Int) = (x: @switch) match { - case 1 => 1 - case _ => 2 - } -} diff --git a/test/files/neg/t3240.scala b/test/files/pos/t3240.scala index cf197a406d..cf197a406d 100644 --- a/test/files/neg/t3240.scala +++ b/test/files/pos/t3240.scala diff --git a/test/files/pos/t3368.flags b/test/files/pos/t3368.flags new file mode 100644 index 0000000000..cb20509902 --- /dev/null +++ b/test/files/pos/t3368.flags @@ -0,0 +1 @@ +-Ystop-after:parser diff --git a/test/files/pos/t3368.scala b/test/files/pos/t3368.scala new file mode 100644 index 0000000000..c8e861a899 --- /dev/null +++ b/test/files/pos/t3368.scala @@ -0,0 +1,5 @@ + +trait X { + // error: in XML literal: name expected, but char '!' cannot start a name + def x = <![CDATA[hi & bye]]> <![CDATA[red & black]]> +} diff --git a/test/files/pos/t3439.scala b/test/files/pos/t3439.scala new file mode 100644 index 0000000000..ccc75cc4cf --- /dev/null +++ b/test/files/pos/t3439.scala @@ -0,0 +1,26 @@ +class Base[M](i: Int) + +// was "implicit modifier not allowed on top level objects" +class D1()(implicit i: Int) extends Base({println(i); 0}) + +// what "no implicit value of type Int found" +class D2()(implicit i: Int) extends Base(implicitly[Int]) + + +abstract class ParametricMessage[M: Manifest](msg: M) { def message = msg } +case class ParametricMessage1[M: Manifest](msg: M, p1: Class[_]) extends ParametricMessage(msg) + + +class Wrap { + class Base[M](i: Int) + + // was "implicit modifier not allowed on top level objects" + class D1()(implicit i: Int) extends Base({println(i); 0}) + + // what "no implicit value of type Int found" + class D2()(implicit i: Int) extends Base(implicitly[Int]) + + + abstract class ParametricMessage[M: Manifest](msg: M) { def message = msg } + case class ParametricMessage1[M: Manifest](msg: M, p1: Class[_]) extends ParametricMessage(msg) +} diff --git a/test/files/pos/t4070.scala b/test/files/pos/t4070.scala index a9777f02ed..11af67a529 100644 --- a/test/files/pos/t4070.scala +++ b/test/files/pos/t4070.scala @@ -20,7 +20,7 @@ package b { /* -// With crash below the clasess: +// With crash below the classes: % scalac -Dscalac.debug.tvar ./a.scala [ create] ?_$1 ( In Foo#crash ) [ setInst] tv[Int] ( In Foo#crash, _$1=tv[Int] ) diff --git a/test/files/pos/t5154.scala b/test/files/pos/t5154.scala new file mode 100644 index 0000000000..2629308f00 --- /dev/null +++ b/test/files/pos/t5154.scala @@ -0,0 +1,9 @@ + +trait Z { + // extra space made the pattern OK + def f = <z> {{3}}</z> match { case <z> {{3}}</z> => } + + // lack of space: error: illegal start of simple pattern + def g = <z>{{3}}</z> match { case <z>{{3}}</z> => } +} + diff --git a/test/files/pos/t5217.scala b/test/files/pos/t5217.scala new file mode 100644 index 0000000000..1fe3f5696f --- /dev/null +++ b/test/files/pos/t5217.scala @@ -0,0 +1,17 @@ +// private types and terms of companion module are +// available in scope of ctor params. +// before 2.10.1, class B in object A cannot be accessed in object A +object A { + private class B + private val b: B = new B + private type C = Int + def apply(): A = new A() +} +// if not private, then default arg results in: +// private class B escapes its defining scope as part of type A.B +class A private (b: A.B = A.b, c: A.C = 42) + +object C { + private class B +} +class C(b: C.B) diff --git a/test/files/pos/t5413.scala b/test/files/pos/t5413.scala new file mode 100644 index 0000000000..47af514a14 --- /dev/null +++ b/test/files/pos/t5413.scala @@ -0,0 +1,9 @@ +object Fail { + def nom (guard : => Boolean) (something : => Unit) { } + def main(args: Array[String]) { + nom { + val i = 0 + (i != 3) + }() + } +} diff --git a/test/files/pos/t5454.scala b/test/files/pos/t5454.scala new file mode 100644 index 0000000000..4045f3b57b --- /dev/null +++ b/test/files/pos/t5454.scala @@ -0,0 +1,10 @@ +object IllegalInheritance { + trait A + implicit def a = new A {} // def => val + //val r = implicitly[A] // uncomment + + class B[T](t : T)(implicit a : A) // remove implicit param block + + class C extends B/*[Int]*/(23) // uncomment + val c = new C // comment +} diff --git a/test/files/pos/t5639.flags b/test/files/pos/t5639.flags new file mode 100644 index 0000000000..0acce1e7ce --- /dev/null +++ b/test/files/pos/t5639.flags @@ -0,0 +1 @@ +-Xsource:2.12 diff --git a/test/files/pos/t5639/A_1.scala b/test/files/pos/t5639/A_1.scala new file mode 100644 index 0000000000..c5da10eae4 --- /dev/null +++ b/test/files/pos/t5639/A_1.scala @@ -0,0 +1,17 @@ +import Implicits._ + +class Baz + +object Test { + implicitly[Int] +} + +object Implicits { + implicit val Baz: Int = 0 + // This implicit was being ignored by `isQualifyingImplicit` + // if the classpath contained a class file for `class Baz`. + // This is because the package scope contains a speculative + // symbol for `object Baz` which is entered by `SymbolLoaders` + // before looking inside the class file. (A Java originated + // classfile results in the class/module symbol pair.) +} diff --git a/test/files/pos/t5639/A_2.scala b/test/files/pos/t5639/A_2.scala new file mode 100644 index 0000000000..2bb36273e0 --- /dev/null +++ b/test/files/pos/t5639/A_2.scala @@ -0,0 +1,11 @@ +import Implicits._ + +class Baz + +object Test { + implicitly[Int] +} + +object Implicits { + implicit val Baz: Int = 0 +} diff --git a/test/files/pos/t5639/Bar.scala b/test/files/pos/t5639/Bar.scala deleted file mode 100644 index f577500acd..0000000000 --- a/test/files/pos/t5639/Bar.scala +++ /dev/null @@ -1,7 +0,0 @@ -package pack.age - -import pack.age.Implicits._ - -object Quux { - def baz : Baz = 1 -} diff --git a/test/files/pos/t5639/Foo.scala b/test/files/pos/t5639/Foo.scala deleted file mode 100644 index 1a07734a8e..0000000000 --- a/test/files/pos/t5639/Foo.scala +++ /dev/null @@ -1,7 +0,0 @@ -package pack.age - -class Baz - -object Implicits { - implicit def Baz(n: Int): Baz = new Baz -} diff --git a/test/files/pos/t6051.scala b/test/files/pos/t6051.scala new file mode 100644 index 0000000000..854524feb9 --- /dev/null +++ b/test/files/pos/t6051.scala @@ -0,0 +1,19 @@ +object Foo1 { + def foo(x: Int, y: Int = 10) = x*y + lazy val y = foo(x = 20) +} + +object Foo2 { + def foo(x: Int, y: Int = 10) = x*y + val y = foo(x = 20) +} + +object Foo3 { + def foo(x: Int, y: Int = 10) = x*y + def y = foo(x = 20) +} + +object Foo4 { + def foo(x: Int, y: Int = 10) = x*y + var y = foo(x = 20) +} diff --git a/test/files/pos/t6582_exhaust_big.scala b/test/files/pos/t6582_exhaust_big.scala new file mode 100644 index 0000000000..7bb8879805 --- /dev/null +++ b/test/files/pos/t6582_exhaust_big.scala @@ -0,0 +1,33 @@ +sealed abstract class Z +object Z { + object Z0 extends Z + case class Z1() extends Z + object Z2 extends Z + case class Z3() extends Z + object Z4 extends Z + case class Z5() extends Z + object Z6 extends Z + case class Z7() extends Z + object Z8 extends Z + case class Z9() extends Z + object Z10 extends Z + case class Z11() extends Z + object Z12 extends Z + case class Z13() extends Z + object Z14 extends Z + case class Z15() extends Z + object Z16 extends Z + case class Z17() extends Z + object Z18 extends Z + case class Z19() extends Z +} + +// drop any case and it will report an error +object Test { + import Z._ + def foo(z: Z) = z match { + case Z0 | Z1() | Z2 | Z3() | Z4 | Z5() | Z6 | Z7() | Z8 | Z9() | + Z10 | Z11() | Z12 | Z13() | Z14 | Z15() | Z16 | Z17() | Z18 | Z19() + => + } +} diff --git a/test/files/pos/t6942.flags b/test/files/pos/t6942.flags index e8fb65d50c..0f96f1f872 100644 --- a/test/files/pos/t6942.flags +++ b/test/files/pos/t6942.flags @@ -1 +1 @@ --Xfatal-warnings
\ No newline at end of file +-nowarn
\ No newline at end of file diff --git a/test/files/pos/t7459a.scala b/test/files/pos/t7459a.scala new file mode 100644 index 0000000000..5107715e06 --- /dev/null +++ b/test/files/pos/t7459a.scala @@ -0,0 +1,18 @@ +trait SpecialException extends Throwable + +object Test { + def run() { + try { + ??? + } catch { + case e: SpecialException => e.isInstanceOf[SpecialException] + case e => + } + + // OKAY + // (null: Throwable) match { + // case e: SpecialException => e.isInstanceOf[SpecialException] + // case e => + // } + } +}
\ No newline at end of file diff --git a/test/files/pos/t7459b.scala b/test/files/pos/t7459b.scala new file mode 100644 index 0000000000..a4b4fd07a9 --- /dev/null +++ b/test/files/pos/t7459b.scala @@ -0,0 +1,12 @@ +import scala.concurrent._ +import scala.util._ + + +class Test { + (null: Any) match { + case s @ Some(_) => ??? + case f @ _ => + () => f + ??? + } +}
\ No newline at end of file diff --git a/test/files/pos/t7459c.scala b/test/files/pos/t7459c.scala new file mode 100644 index 0000000000..dc2605abe6 --- /dev/null +++ b/test/files/pos/t7459c.scala @@ -0,0 +1,18 @@ +object Test { + trait Universe { + type Type + type TypeTag[A] >: Null <: TypeTagApi[A] + trait TypeTagApi[A] { def tpe: Type } + } + trait JavaUniverse extends Universe + + trait Mirror[U <: Universe] { + def universe: U + } + (null: Mirror[_]).universe match { + case ju: JavaUniverse => + val ju1 = ju + val f = {() => (null: ju.TypeTag[Nothing]).tpe } + } + trait M[A] +} diff --git a/test/files/pos/t7459d.scala b/test/files/pos/t7459d.scala new file mode 100644 index 0000000000..7843156885 --- /dev/null +++ b/test/files/pos/t7459d.scala @@ -0,0 +1,8 @@ +class Test { + (null: Any) match { + case s @ Some(_) => ??? + case f @ _ => + () => f + ??? + } +} diff --git a/test/files/pos/t7596/A_1.scala b/test/files/pos/t7596/A_1.scala new file mode 100644 index 0000000000..6303c6d132 --- /dev/null +++ b/test/files/pos/t7596/A_1.scala @@ -0,0 +1,10 @@ +trait Driver { + abstract class Table +} + +object Config { + val driver : Driver = ??? + def driver(a: Any) = ??? +} + +object Sites extends Config.driver.Table diff --git a/test/files/pos/t7596/B_2.scala b/test/files/pos/t7596/B_2.scala new file mode 100644 index 0000000000..977e5c8bd1 --- /dev/null +++ b/test/files/pos/t7596/B_2.scala @@ -0,0 +1,19 @@ +object Test { + locally { + Sites: Config.driver.Table + } +} + +// Under separate compilation, the pickler is foiled by the +// overloaded term `Config.driver`, and results in: + +// qbin/scalac test/files/pos/t7596/A_1.scala && qbin/scalac -explaintypes test/files/pos/t7596/B_2.scala +// test/files/pos/t7596/B_2.scala:3: error: type mismatch; +// found : Sites.type +// required: Config.driver.Table +// Sites: Config.driver.Table +// ^ +// Sites.type <: Config.driver.Table? +// Driver.this.type = Config.driver.type? +// false +// false
\ No newline at end of file diff --git a/test/files/pos/t7596b/A.scala b/test/files/pos/t7596b/A.scala new file mode 100644 index 0000000000..65c1bc56ef --- /dev/null +++ b/test/files/pos/t7596b/A.scala @@ -0,0 +1,10 @@ +trait H2Driver{ + abstract class Table[T] +} + +object Config { + val driver : H2Driver = ??? + def driver(app: Any): H2Driver = ??? +} + +class Sites extends Config.driver.Table[String] diff --git a/test/files/pos/t7596b/B.scala b/test/files/pos/t7596b/B.scala new file mode 100644 index 0000000000..cbcf149c23 --- /dev/null +++ b/test/files/pos/t7596b/B.scala @@ -0,0 +1,6 @@ +class DAOBase[E]{ + type TableType <: Config.driver.Table[E] +} +class SitesDAO extends DAOBase[String]{ + type TableType = Sites +} diff --git a/test/files/pos/t7596c/A_1.scala b/test/files/pos/t7596c/A_1.scala new file mode 100644 index 0000000000..3e366df477 --- /dev/null +++ b/test/files/pos/t7596c/A_1.scala @@ -0,0 +1,11 @@ +trait Driver { + abstract class Table +} + +object Config { + val driver : Driver = ??? + val driverUniqueName: driver.type = driver + def driver(a: Any) = ??? +} + +object Sites extends Config.driver.Table diff --git a/test/files/pos/t7596c/B_2.scala b/test/files/pos/t7596c/B_2.scala new file mode 100644 index 0000000000..33da68c1ff --- /dev/null +++ b/test/files/pos/t7596c/B_2.scala @@ -0,0 +1,9 @@ +object Test { + locally { + Sites: Config.driver.Table + } +} + +// This variation worked by avoiding referring to the +// overloaded term `Config.driver` in the parent type of +// Sites
\ No newline at end of file diff --git a/test/files/pos/t7683-stop-after-parser/ThePlugin.scala b/test/files/pos/t7683-stop-after-parser/ThePlugin.scala new file mode 100644 index 0000000000..cd800781dc --- /dev/null +++ b/test/files/pos/t7683-stop-after-parser/ThePlugin.scala @@ -0,0 +1,31 @@ +package scala.test.plugins + +import scala.tools.nsc +import nsc.Global +import nsc.Phase +import nsc.plugins.Plugin +import nsc.plugins.PluginComponent + +class ThePlugin(val global: Global) extends Plugin { + import global._ + + val name = "timebomb" + val description = "Explodes if run. Maybe I haven't implemented it yet." + val components = List[PluginComponent](thePhase1) + + private object thePhase1 extends PluginComponent { + val global = ThePlugin.this.global + + val runsAfter = List[String]("parser") + override val runsBefore = List[String]("namer") + val phaseName = ThePlugin.this.name + + def newPhase(prev: Phase) = new ThePhase(prev) + } + + private class ThePhase(prev: Phase) extends Phase(prev) { + override def name = ThePlugin.this.name + override def run = ??? + } +} + diff --git a/test/files/pos/t7683-stop-after-parser/sample_2.flags b/test/files/pos/t7683-stop-after-parser/sample_2.flags new file mode 100644 index 0000000000..99672cdfd3 --- /dev/null +++ b/test/files/pos/t7683-stop-after-parser/sample_2.flags @@ -0,0 +1 @@ +-Xplugin:. -Xplugin-require:timebomb -Ystop-after:parser diff --git a/test/files/pos/t7683-stop-after-parser/sample_2.scala b/test/files/pos/t7683-stop-after-parser/sample_2.scala new file mode 100644 index 0000000000..7eb11b8204 --- /dev/null +++ b/test/files/pos/t7683-stop-after-parser/sample_2.scala @@ -0,0 +1,6 @@ + +package sample + +// just a sample that is compiled with the explosive plugin disabled +object Sample extends App { +} diff --git a/test/files/pos/t7683-stop-after-parser/scalac-plugin.xml b/test/files/pos/t7683-stop-after-parser/scalac-plugin.xml new file mode 100644 index 0000000000..2558d6fd03 --- /dev/null +++ b/test/files/pos/t7683-stop-after-parser/scalac-plugin.xml @@ -0,0 +1,5 @@ +<plugin> + <name>ignored</name> + <classname>scala.test.plugins.ThePlugin</classname> +</plugin> + diff --git a/test/files/pos/t7704.scala b/test/files/pos/t7704.scala new file mode 100644 index 0000000000..cae88d3324 --- /dev/null +++ b/test/files/pos/t7704.scala @@ -0,0 +1,10 @@ +class Attr { type V ; class Val } +class StrAttr extends Attr { type V = String } +class BoolAttr extends Attr { type V = Boolean } + +object Main { + def f(x: Attr) = x match { + case v: StrAttr => new v.Val + case v: BoolAttr => new v.Val + } +} diff --git a/test/files/pos/t7750.flags b/test/files/pos/t7750.flags new file mode 100644 index 0000000000..b216e74c97 --- /dev/null +++ b/test/files/pos/t7750.flags @@ -0,0 +1 @@ +-Xfatal-warnings -feature diff --git a/test/files/pos/t7750.scala b/test/files/pos/t7750.scala new file mode 100644 index 0000000000..befec76949 --- /dev/null +++ b/test/files/pos/t7750.scala @@ -0,0 +1,8 @@ +trait LazyCombiner[Elem, +To, Buff <: Growable[Elem] with Sizing] +trait Growable[T] +trait Sizing + + +object Test { + null.isInstanceOf[LazyCombiner[_, _, _]] // issued an existential feature warning +} diff --git a/test/files/pos/t7815.scala b/test/files/pos/t7815.scala index 12a434c5b0..0a126f9faa 100644 --- a/test/files/pos/t7815.scala +++ b/test/files/pos/t7815.scala @@ -21,7 +21,7 @@ object Foo { object Main extends App { def mapWithFoo[A <: AnyRef, B](as: List[A])(implicit foo: Foo.Aux[A, B]) = { // Should be Eta expandable because the result type of `f` is not - // dependant on the value, it is just `B`. + // dependent on the value, it is just `B`. as map foo.f as map foo.g as map foo.m diff --git a/test/files/pos/t8013.flags b/test/files/pos/t8013.flags index 954eaba352..3955bb6710 100644 --- a/test/files/pos/t8013.flags +++ b/test/files/pos/t8013.flags @@ -1 +1 @@ --Xfatal-warnings -Xlint +-Xfatal-warnings -Xlint:-infer-any,_ diff --git a/test/files/pos/t8157-2.10.flags b/test/files/pos/t8157-2.10.flags new file mode 100644 index 0000000000..94c8056747 --- /dev/null +++ b/test/files/pos/t8157-2.10.flags @@ -0,0 +1 @@ +-Xsource:2.10 diff --git a/test/files/pos/t8157-2.10.scala b/test/files/pos/t8157-2.10.scala new file mode 100644 index 0000000000..597585a96d --- /dev/null +++ b/test/files/pos/t8157-2.10.scala @@ -0,0 +1,5 @@ +object Test { // PolyTYped function default arg unicity check, + // fails in 2.11, authorized under -Xsource:2.10 + def foo(printer: Any, question: => String, show: Boolean = false)(op: => Any): Any = ??? + def foo[T](question: => String, show: Boolean)(op: => Any = ()): Any = ??? +} diff --git a/test/files/pos/t8267.scala b/test/files/pos/t8267.scala new file mode 100644 index 0000000000..37b498fe3e --- /dev/null +++ b/test/files/pos/t8267.scala @@ -0,0 +1,33 @@ +class Bippy { trait Foo[A] } + +final class RichBippy[C <: Bippy with Singleton](val c1: C) { + def f: Int = 1 + def f[A](x: A)(ev: c1.Foo[A]): Int = 2 + + def g[A <: Nothing](x: A): Int = 1 + def g[A](x: A)(ev: c1.Foo[A]): Int = 2 + + def h[A](x: A)(ev: c1.Foo[A]): Int = 1 + + def i(x: Nothing): Int = 1 + def i(x: AnyRef)(ev: c1.Foo[x.type]): Int = 2 +} + +object p { + + val c = new Bippy + val d0 = new RichBippy[c.type](c) + def d1 = new RichBippy[c.type](c) + + d0.f[Int](5)(null: c.Foo[Int]) // ok + d1.f[Int](5)(null: c.Foo[Int]) // fails + + d0.g[Int](5)(null: c.Foo[Int]) // ok + d1.g[Int](5)(null: c.Foo[Int]) // fails + + d0.h[Int](5)(null: c.Foo[Int]) // ok + d1.h[Int](5)(null: c.Foo[Int]) // ok + + d0.i("")(null) // ok + d1.i("")(null) // ok +} diff --git a/test/files/pos/t8310.flags b/test/files/pos/t8310.flags new file mode 100644 index 0000000000..48fd867160 --- /dev/null +++ b/test/files/pos/t8310.flags @@ -0,0 +1 @@ +-Xexperimental diff --git a/test/files/pos/t8310.scala b/test/files/pos/t8310.scala new file mode 100644 index 0000000000..874caf4d3b --- /dev/null +++ b/test/files/pos/t8310.scala @@ -0,0 +1,22 @@ +trait Comparinator[T] { def compare(a: T, b: T): Int } + +object TestOkay { + def sort(x: Comparinator[_ >: String]) = () + sort((a: String, b: String) => a.compareToIgnoreCase(b)) +} + +object TestOkay2 { + def sort[T](x: Comparinator[_ >: T]) = () + sort((a: String, b: String) => a.compareToIgnoreCase(b)) +} + +object TestOkay3 { + def sort[T](xs: Option[T], x: Comparinator[_ >: T]) = () + sort(Some(""), (a: String, b: String) => a.compareToIgnoreCase(b)) +} + +object TestKoOverloaded { + def sort[T](xs: Option[T]) = () + def sort[T](xs: Option[T], x: Comparinator[_ >: T]) = () + sort(Some(""), (a: String, b: String) => a.compareToIgnoreCase(b)) +} diff --git a/test/files/pos/t8325.scala b/test/files/pos/t8325.scala new file mode 100644 index 0000000000..af33ee7bb3 --- /dev/null +++ b/test/files/pos/t8325.scala @@ -0,0 +1,9 @@ + +trait Test { + type +[A, B] = (A, B) + type *[A, B] = (A, B) + + type X[A, B] = A + B + type Y[A, B] = A * B + type Z[A, B] = A `*` B +} diff --git a/test/files/pos/t8329.scala b/test/files/pos/t8329.scala new file mode 100644 index 0000000000..fcd5e50b37 --- /dev/null +++ b/test/files/pos/t8329.scala @@ -0,0 +1,29 @@ +object Test { + def pf(pf: PartialFunction[Any, Unit]) = () + def f1(pf: Function[Any, Unit]) = () + + class A1; class B1 + def test1(x: String, x1: String, default: String) = pf { + case _ if ( + x.isEmpty + && default.isEmpty // was binding to synthetic param + && x1.isEmpty // was binding to synthetic param + ) => + x.isEmpty + default.isEmpty // was binding to synthetic param + x1.isEmpty // was binding to synthetic param + new A1; new B1 + } + + def test2(x: String, x1: String, default: String) = f1 { + case _ if ( + x.isEmpty + && default.isEmpty + && x1.isEmpty + ) => + x.isEmpty + default.isEmpty + x1.isEmpty + new A1; new B1 + } +} diff --git a/test/files/pos/t8359-closelim-crash.flags b/test/files/pos/t8359-closelim-crash.flags new file mode 100644 index 0000000000..49d036a887 --- /dev/null +++ b/test/files/pos/t8359-closelim-crash.flags @@ -0,0 +1 @@ +-optimize diff --git a/test/files/pos/t8359-closelim-crash.scala b/test/files/pos/t8359-closelim-crash.scala new file mode 100644 index 0000000000..1413694d10 --- /dev/null +++ b/test/files/pos/t8359-closelim-crash.scala @@ -0,0 +1,23 @@ +package test + +// This is a minimization of code that crashed the compiler during bootstrapping +// in the first iteration of https://github.com/scala/scala/pull/4373, the PR +// that adjusted the order of free and declared params in LambdaLift. + +// Was: +// java.lang.AssertionError: assertion failed: +// Record Record(<$anon: Function1>,Map(value a$1 -> Deref(LocalVar(value b)))) does not contain a field value b$1 +// at scala.tools.nsc.Global.assert(Global.scala:262) +// at scala.tools.nsc.backend.icode.analysis.CopyPropagation$copyLattice$State.getFieldNonRecordValue(CopyPropagation.scala:113) +// at scala.tools.nsc.backend.icode.analysis.CopyPropagation$copyLattice$State.getFieldNonRecordValue(CopyPropagation.scala:122) +// at scala.tools.nsc.backend.opt.ClosureElimination$ClosureElim$$anonfun$analyzeMethod$1$$anonfun$apply$2.replaceFieldAccess$1(ClosureElimination.scala:124) +class Typer { + def bar(a: Boolean, b: Boolean): Unit = { + @inline + def baz(): Unit = { + ((_: Any) => (Typer.this, a, b)).apply("") + } + ((_: Any) => baz()).apply("") + } +} + diff --git a/test/files/pos/t8410.flags b/test/files/pos/t8410.flags new file mode 100644 index 0000000000..dcd5943c2f --- /dev/null +++ b/test/files/pos/t8410.flags @@ -0,0 +1 @@ +-optimise -Xfatal-warnings -deprecation:false -Yinline-warnings:false diff --git a/test/files/pos/t8410.scala b/test/files/pos/t8410.scala new file mode 100644 index 0000000000..4d862311fa --- /dev/null +++ b/test/files/pos/t8410.scala @@ -0,0 +1,15 @@ + +object Test extends App { + @deprecated("","") def f = 42 + @deprecated("","") def z = f + def g = { @deprecated("","") def _f = f ; _f } // warns in 2.11.0-M8 + def x = { @deprecated("","") class X { def x = f } ; new X().x } // warns in 2.11.0-M8 + Console println g + Console println f // warns + + @deprecated("","") trait T + object T extends T { def t = f } + Console println T.t + + def k = List(0).dropWhile(_ < 1) // inlining warns doubly +} diff --git a/test/files/neg/t845.scala b/test/files/pos/t845.scala index ddf6a16f32..ddf6a16f32 100644 --- a/test/files/neg/t845.scala +++ b/test/files/pos/t845.scala diff --git a/test/files/pos/t8497/A_1.scala b/test/files/pos/t8497/A_1.scala new file mode 100644 index 0000000000..6a76b0ee99 --- /dev/null +++ b/test/files/pos/t8497/A_1.scala @@ -0,0 +1,13 @@ +package p { + object Crash { + def e(s: (String @java.lang.Deprecated)): Unit = () + def f(s: (String @nonStatic)): Unit = () + } + object Ok { + def g(s: (String @nonStatic @static)): Unit = () + def h(s: (String @static)): Unit = () + } +} + +class nonStatic extends scala.annotation.Annotation +class static extends scala.annotation.StaticAnnotation diff --git a/test/files/pos/t8497/B_2.scala b/test/files/pos/t8497/B_2.scala new file mode 100644 index 0000000000..efe2edf2c3 --- /dev/null +++ b/test/files/pos/t8497/B_2.scala @@ -0,0 +1 @@ +package p { object Test { Crash } } diff --git a/test/files/pos/t8498.scala b/test/files/pos/t8498.scala new file mode 100644 index 0000000000..6808c89051 --- /dev/null +++ b/test/files/pos/t8498.scala @@ -0,0 +1,6 @@ +import scala.annotation.compileTimeOnly + +class C(val s: String) extends AnyVal { + @compileTimeOnly("error") + def error = ??? +} diff --git a/test/files/pos/t8523.flags b/test/files/pos/t8523.flags new file mode 100644 index 0000000000..c7d406c649 --- /dev/null +++ b/test/files/pos/t8523.flags @@ -0,0 +1 @@ +-Ywarn-dead-code -Xfatal-warnings
\ No newline at end of file diff --git a/test/files/pos/t8523.scala b/test/files/pos/t8523.scala new file mode 100644 index 0000000000..dfcb35404d --- /dev/null +++ b/test/files/pos/t8523.scala @@ -0,0 +1,10 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.Context + +class Impl(val c: Context) { + def impl: c.Tree = ??? +} + +object Macros { + def foo: Any = macro Impl.impl +}
\ No newline at end of file diff --git a/test/files/pos/t8531/MyEnum.java b/test/files/pos/t8531/MyEnum.java new file mode 100644 index 0000000000..06cc128a79 --- /dev/null +++ b/test/files/pos/t8531/MyEnum.java @@ -0,0 +1,5 @@ + +package foobar; +public enum MyEnum { +A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64, A65, A66, A67, A68, A69, A70, A71, A72, A73, A74, A75, A76, A77, A78, A79, A80, A81, A82, A83, A84, A85, A86, A87, A88, A89, A90, A91, A92, A93, A94, A95, A96, A97, A98, A99, A100, A101, A102, A103, A104, A105, A106, A107, A108, A109, A110, A111, A112, A113, A114, A115, A116, A117, A118, A119, A120, A121, A122, A123, A124, A125, A126, A127, A128, A129, A130, A131, A132, A133, A134, A135, A136, A137, A138, A139, A140, A141, A142, A143, A144, A145, A146, A147, A148, A149, A150, A151, A152, A153, A154, A155, A156, A157, A158, A159, A160, A161, A162, A163, A164, A165, A166, A167, A168, A169, A170, A171, A172, A173, A174, A175, A176, A177, A178, A179, A180, A181, A182, A183, A184, A185, A186, A187, A188, A189, A190, A191, A192, A193; +} diff --git a/test/files/pos/t8531/Test.scala b/test/files/pos/t8531/Test.scala new file mode 100644 index 0000000000..59861435a6 --- /dev/null +++ b/test/files/pos/t8531/Test.scala @@ -0,0 +1,24 @@ +package test + +// takes > 50s and > 800M heap to compile under 2.11.0 +import foobar._ +class `SI-8531` { + //https://issues.scala-lang.org/browse/SI-8531 + + import MyEnum._ + def foo(e1: MyEnum, e2: MyEnum) = (e1, e2) match { + case (A1, x) => "a1" + case (x, A1) => "a1" + case (A2, x) => "a2" + case (x, A2) => "a2" + case (A3, x) => "a3" + case (x, A3) => "a3" + case (A4, x) => "a4" + case (x, A4) => "a4" + case (A5, x) => "a5" + case (x, A5) => "a5" + case (A6, x) => "a6" + case (x, A6) => "a6" + case (a, b) => "ab" + } +} diff --git a/test/files/pos/t8546.flags b/test/files/pos/t8546.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/pos/t8546.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/pos/t8546.scala b/test/files/pos/t8546.scala new file mode 100644 index 0000000000..c39d749b4c --- /dev/null +++ b/test/files/pos/t8546.scala @@ -0,0 +1,49 @@ +package test + +class F1() { + private sealed abstract class T + private case class A(m: Int) extends T + private case class B() extends T + private case object C extends T + + // No warnings here + private def foo(t: T) = t match { + case A(m) => println("A:" + m) + case B() => println("B") + case C => println("C") + } + + def test(m: Int): Unit = { + foo(A(m)) + foo(B()) + foo(C) + } +} + +class F2[M]() { + private sealed abstract class T + private case class A(m: M) extends T + private case class B() extends T + private case object C extends T + + // match may not be exhaustive. It would fail on the following input: C + private def foo(t: T) = t match { + case A(m) => println("A:" + m) + case B() => println("B") + case C => println("C") + } + + def test(m: M): Unit = { + foo(A(m)) + foo(B()) + foo(C) + } + +} + +object Test { + def main(args: Array[String]): Unit = { + new F1().test(1) + new F2[Int]().test(1) + } +}
\ No newline at end of file diff --git a/test/files/pos/t8578.flags b/test/files/pos/t8578.flags new file mode 100644 index 0000000000..48b438ddf8 --- /dev/null +++ b/test/files/pos/t8578.flags @@ -0,0 +1 @@ +-Ydelambdafy:method diff --git a/test/files/pos/t8578.scala b/test/files/pos/t8578.scala new file mode 100644 index 0000000000..879b5f5550 --- /dev/null +++ b/test/files/pos/t8578.scala @@ -0,0 +1,18 @@ +class DuplicateClassName { + () => { + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => () => ()} + {() => ()} + } +} +// Was: +// Different class symbols have the same bytecode-level internal name: +// name: DuplicateClassName$lambda$$$anonfun$111
\ No newline at end of file diff --git a/test/files/pos/t8596.flags b/test/files/pos/t8596.flags new file mode 100644 index 0000000000..281f0a10cd --- /dev/null +++ b/test/files/pos/t8596.flags @@ -0,0 +1 @@ +-Yrangepos diff --git a/test/files/pos/t8596.scala b/test/files/pos/t8596.scala new file mode 100644 index 0000000000..bfed58eadf --- /dev/null +++ b/test/files/pos/t8596.scala @@ -0,0 +1,7 @@ +class TypeTreeObjects { + class Container { + def typeParamAndDefaultArg[C](name: String = ""): String = "" + } + // crashed under -Yrangepos + new Container().typeParamAndDefaultArg[Any]() +} diff --git a/test/files/pos/t8617.flags b/test/files/pos/t8617.flags new file mode 100644 index 0000000000..281f0a10cd --- /dev/null +++ b/test/files/pos/t8617.flags @@ -0,0 +1 @@ +-Yrangepos diff --git a/test/files/pos/t8617.scala b/test/files/pos/t8617.scala new file mode 100644 index 0000000000..fc825bbcba --- /dev/null +++ b/test/files/pos/t8617.scala @@ -0,0 +1,10 @@ +object Test { + def foo[A] = implicitly[OptManifest[A]] // was "unpositioned tree" under -Yrangepos + + // These did not crash, but testing for good measure. + implicitly[OptManifest[String]] + implicitly[Manifest[String]] + + implicitly[reflect.ClassTag[String]] + implicitly[reflect.runtime.universe.TypeTag[String]] +} diff --git a/test/files/pos/t8625.scala b/test/files/pos/t8625.scala new file mode 100644 index 0000000000..95c4b0dbcd --- /dev/null +++ b/test/files/pos/t8625.scala @@ -0,0 +1,5 @@ +object Test { + def f1(a: Boolean, b: Boolean) = (a || ???) && (b || ???) + def f2(a: Boolean, b: Boolean) = (a || ???) && b + def f3(a: Boolean, b: Boolean) = (a && ???) || b +} diff --git a/test/files/pos/t8708/Either_1.scala b/test/files/pos/t8708/Either_1.scala new file mode 100644 index 0000000000..000ed6e7c2 --- /dev/null +++ b/test/files/pos/t8708/Either_1.scala @@ -0,0 +1,6 @@ +sealed trait \/[+A, +B] + +sealed trait EitherT[F[+_], +A, +B] +object EitherT { + def apply[F[+_], A, B](a: F[A \/ B]): EitherT[F, A, B] = new EitherT[F, A, B] { val run = a } +} diff --git a/test/files/pos/t8708/Test_2.scala b/test/files/pos/t8708/Test_2.scala new file mode 100644 index 0000000000..d0e56b9a37 --- /dev/null +++ b/test/files/pos/t8708/Test_2.scala @@ -0,0 +1,13 @@ +import scala.language.higherKinds + +trait ClientTypes[M[+_]] { + final type Context[+A] = EitherT[M, String, A] + object Context { + def apply[A](ca: M[String \/ A]): Context[A] = EitherT[M, String, A](ca) + } + + final type StatefulContext[+A] = EitherT[Context, String, A] + object StatefulContext { + def apply[A](state: Context[String \/ A]): StatefulContext[A] = ??? + } +} diff --git a/test/files/pos/t8719.check b/test/files/pos/t8719.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/pos/t8719.check diff --git a/test/files/pos/t8719/Macros_1.scala b/test/files/pos/t8719/Macros_1.scala new file mode 100644 index 0000000000..152c92f254 --- /dev/null +++ b/test/files/pos/t8719/Macros_1.scala @@ -0,0 +1,21 @@ +import scala.language.experimental.macros +import scala.reflect.macros.TypecheckException +import scala.reflect.macros.whitebox.Context + +object Macros { + def typecheck_impl(c: Context)(code: c.Expr[String]): c.Expr[Option[String]] = { + import c.universe._ + + val Expr(Literal(Constant(codeStr: String))) = code + + try { + c.typecheck(c.parse(codeStr)) + c.Expr(q"None: Option[String]") + } catch { + case e: TypecheckException => + c.Expr(q"Some(${ e.toString }): Option[String]") + } + } + + def typecheck(code: String): Option[String] = macro typecheck_impl +}
\ No newline at end of file diff --git a/test/files/pos/t8719/Test_2.scala b/test/files/pos/t8719/Test_2.scala new file mode 100644 index 0000000000..997eb2f236 --- /dev/null +++ b/test/files/pos/t8719/Test_2.scala @@ -0,0 +1,10 @@ +case class Foo(i: Int, c: Char) + +object Bar { + def unapply(foo: Foo): Option[(Int, Char)] = Some((foo.i, foo.c)) +} + +object Test extends App { + println(Macros.typecheck("val Foo(x, y, z) = Foo(1, 'a')")) + println(Macros.typecheck("val Bar(x, y, z) = Foo(1, 'a')")) +}
\ No newline at end of file diff --git a/test/files/pos/t8736-b.flags b/test/files/pos/t8736-b.flags new file mode 100644 index 0000000000..1ad4eabe0f --- /dev/null +++ b/test/files/pos/t8736-b.flags @@ -0,0 +1 @@ +-feature -language:_ -Xfatal-warnings diff --git a/test/files/pos/t8736-b.scala b/test/files/pos/t8736-b.scala new file mode 100644 index 0000000000..903292d232 --- /dev/null +++ b/test/files/pos/t8736-b.scala @@ -0,0 +1,7 @@ +// scalac: -feature -language:_ -Xfatal-warnings +// showing that all are set +class X { + def hk[M[_]] = ??? + + implicit def imp(x: X): Int = x.hashCode +} diff --git a/test/files/pos/t8736.flags b/test/files/pos/t8736.flags new file mode 100644 index 0000000000..7fe42f7340 --- /dev/null +++ b/test/files/pos/t8736.flags @@ -0,0 +1 @@ +-feature -language:implicitConversions -language:higherKinds -language:-implicitConversions -Xfatal-warnings diff --git a/test/files/pos/t8736.scala b/test/files/pos/t8736.scala new file mode 100644 index 0000000000..46c0cdfd00 --- /dev/null +++ b/test/files/pos/t8736.scala @@ -0,0 +1,7 @@ +// scalac: -feature -language:implicitConversions -language:higherKinds -language:-implicitConversions -Xfatal-warnings +// showing that multiple settings are respected, and explicit enablement has precedence +class X { + def hk[M[_]] = ??? + + implicit def imp(x: X): Int = x.hashCode +} diff --git a/test/files/pos/t8743.scala b/test/files/pos/t8743.scala new file mode 100644 index 0000000000..03b0cd7044 --- /dev/null +++ b/test/files/pos/t8743.scala @@ -0,0 +1,15 @@ +import annotation.varargs + +object VarArgs { + @varargs + def foo[A](x: A, xs: String*): A = ??? + + @varargs + def bar[A](x: List[A], xs: String*): A = ??? + + @varargs + def baz[A](x: List[A], xs: String*): A = ??? + + @varargs + def boz[A](x: A, xs: String*): Nothing = ??? +} diff --git a/test/files/pos/t8781/Macro_1.scala b/test/files/pos/t8781/Macro_1.scala new file mode 100644 index 0000000000..ecd9c5e8d5 --- /dev/null +++ b/test/files/pos/t8781/Macro_1.scala @@ -0,0 +1,13 @@ +import scala.reflect.macros.whitebox.Context +import language.experimental.macros + +object Macros { + def impl(c: Context) = { + import c.universe._ + val name = TypeName(c.freshName()) + q"class $name extends T; new $name" + } + def fresh: Any = macro impl +} + +trait T diff --git a/test/files/pos/t8781/Test_2.flags b/test/files/pos/t8781/Test_2.flags new file mode 100644 index 0000000000..24e2109690 --- /dev/null +++ b/test/files/pos/t8781/Test_2.flags @@ -0,0 +1 @@ +-Ymacro-expand:discard -Ystop-after:typer diff --git a/test/files/pos/t8781/Test_2.scala b/test/files/pos/t8781/Test_2.scala new file mode 100644 index 0000000000..3ca6406599 --- /dev/null +++ b/test/files/pos/t8781/Test_2.scala @@ -0,0 +1,5 @@ +object Test { + implicit class RichT(t: T) { def augmented = "" } + + Macros.fresh.augmented +} diff --git a/test/files/pos/t8793.scala b/test/files/pos/t8793.scala new file mode 100644 index 0000000000..1276155675 --- /dev/null +++ b/test/files/pos/t8793.scala @@ -0,0 +1,15 @@ +package regr + +trait F[A] + +class G(val a: F[_], val b: F[_]) + +object G { + def unapply(g: G) = Option((g.a, g.b)) +} + +object H { + def unapply(g: G) = g match { + case G(a, _) => Option(a) + } +} diff --git a/test/files/pos/t8801.scala b/test/files/pos/t8801.scala new file mode 100644 index 0000000000..695b456e12 --- /dev/null +++ b/test/files/pos/t8801.scala @@ -0,0 +1,21 @@ +sealed trait Nat { + type Prev <: Nat { type Succ = Nat.this.type } + type Succ <: Nat { type Prev = Nat.this.type } +} + +object Nat { + object Zero extends Nat { + type Prev = Nothing + } + + type _0 = Zero.type + type _1 = _0#Succ + type _2 = _1#Succ + type _3 = _2#Succ + type _4 = _3#Succ + type _5 = _4#Succ + type _6 = _5#Succ + type _7 = _6#Succ + type _8 = _7#Succ + type _9 = _8#Succ +} diff --git a/test/files/pos/t8828.flags b/test/files/pos/t8828.flags new file mode 100644 index 0000000000..e68991f643 --- /dev/null +++ b/test/files/pos/t8828.flags @@ -0,0 +1 @@ +-Xlint:inaccessible -Xfatal-warnings diff --git a/test/files/pos/t8828.scala b/test/files/pos/t8828.scala new file mode 100644 index 0000000000..182aba54c0 --- /dev/null +++ b/test/files/pos/t8828.scala @@ -0,0 +1,20 @@ + +package outer + +package inner { + + private[inner] class A + + // the class is final: no warning + private[outer] final class B { + def doWork(a: A): A = a + } + + // the trait is sealed and doWork is not + // and cannot be overridden: no warning + private[outer] sealed trait C { + def doWork(a: A): A = a + } + + private[outer] final class D extends C +} diff --git a/test/files/pos/t8844.scala b/test/files/pos/t8844.scala new file mode 100644 index 0000000000..d33c520d1b --- /dev/null +++ b/test/files/pos/t8844.scala @@ -0,0 +1,4 @@ +object Example { + type S[A] = String + def foo(s: S[_]): String = s +} diff --git a/test/files/pos/t8861.flags b/test/files/pos/t8861.flags new file mode 100644 index 0000000000..99a6391058 --- /dev/null +++ b/test/files/pos/t8861.flags @@ -0,0 +1 @@ +-Xlint:infer-any -Xfatal-warnings diff --git a/test/files/pos/t8861.scala b/test/files/pos/t8861.scala new file mode 100644 index 0000000000..816d15700e --- /dev/null +++ b/test/files/pos/t8861.scala @@ -0,0 +1,11 @@ + +trait Test { + type R = PartialFunction[Any, Unit] + + val x: R = { case "" => } + val y: R = { case "" => } + + val z: R = x orElse y + val zz = x orElse y +} + diff --git a/test/files/pos/t8868a/Sub_2.scala b/test/files/pos/t8868a/Sub_2.scala new file mode 100644 index 0000000000..a19b529c88 --- /dev/null +++ b/test/files/pos/t8868a/Sub_2.scala @@ -0,0 +1 @@ +class Sub extends T diff --git a/test/files/pos/t8868a/T_1.scala b/test/files/pos/t8868a/T_1.scala new file mode 100644 index 0000000000..9fb97b1413 --- /dev/null +++ b/test/files/pos/t8868a/T_1.scala @@ -0,0 +1,6 @@ +class C + +trait T { + @deprecated(since = "", message = "") + class X +} diff --git a/test/files/pos/t8868b/Sub_2.scala b/test/files/pos/t8868b/Sub_2.scala new file mode 100644 index 0000000000..58b44db2b3 --- /dev/null +++ b/test/files/pos/t8868b/Sub_2.scala @@ -0,0 +1,2 @@ +class Sub extends T + diff --git a/test/files/pos/t8868b/T_1.scala b/test/files/pos/t8868b/T_1.scala new file mode 100644 index 0000000000..0b71cfdaa3 --- /dev/null +++ b/test/files/pos/t8868b/T_1.scala @@ -0,0 +1,4 @@ +@deprecated(since = "2.4.0", message = "") +trait T { + class X +} diff --git a/test/files/pos/t8868c/Sub_2.scala b/test/files/pos/t8868c/Sub_2.scala new file mode 100644 index 0000000000..58b44db2b3 --- /dev/null +++ b/test/files/pos/t8868c/Sub_2.scala @@ -0,0 +1,2 @@ +class Sub extends T + diff --git a/test/files/pos/t8868c/T_1.scala b/test/files/pos/t8868c/T_1.scala new file mode 100644 index 0000000000..dc541950d8 --- /dev/null +++ b/test/files/pos/t8868c/T_1.scala @@ -0,0 +1,9 @@ +class C(a: Any) extends annotation.StaticAnnotation + +@C({val x = 0; x}) +trait T { + class X + + @C({val x = 0; x}) + def foo = 42 +} diff --git a/test/files/pos/t8893.scala b/test/files/pos/t8893.scala new file mode 100644 index 0000000000..b87c8bdd3c --- /dev/null +++ b/test/files/pos/t8893.scala @@ -0,0 +1,129 @@ +// Took > 10 minutes to run the tail call phase. +object Test { + def a(): Option[String] = Some("a") + + def main(args: Array[String]) { + a() match { + case Some(b1) => + a() match { + case Some(b2) => + a() match { + case Some(b3) => + a() match { + case Some(b4) => + a() match { + case Some(b5) => + a() match { + case Some(b6) => + a() match { + case Some(b7) => + a() match { + case Some(b8) => + a() match { + case Some(b9) => + a() match { + case Some(b10) => + a() match { + case Some(b11) => + a() match { + case Some(b12) => + a() match { + case Some(b13) => + a() match { + case Some(b14) => + a() match { + case Some(b15) => + a() match { + case Some(b16) => + a() match { + case Some(b17) => + a() match { + case Some(b18) => + a() match { + case Some(b19) => + a() match { + case Some(b20) => + a() match { + case Some(b21) => + a() match { + case Some(b22) => + a() match { + case Some(b23) => + a() match { + case Some(b24) => + a() match { + case Some(b25) => + a() match { + case Some(b26) => + a() match { + case Some(b27) => + a() match { + case Some(b28) => + a() match { + case Some(b29) => + a() match { + case Some(b30) => + println("yay") + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + case None => None + } + } +} + diff --git a/test/files/pos/t8894.scala b/test/files/pos/t8894.scala new file mode 100644 index 0000000000..3b26f1ae7e --- /dev/null +++ b/test/files/pos/t8894.scala @@ -0,0 +1,12 @@ +class CC(val i: Int, val s: String) +object CC extends { + type P = (Int, String) + + //def unapply(c: CC): Option[(Int, String)] = Some((c.i, c.s)) // OK + def unapply(c: CC): Option[P] = Some((c.i, c.s)) // fails (because of the type alias) +} + +class Test { + val cc = new CC(23, "foo") + val CC(i, s) = cc +}
\ No newline at end of file diff --git a/test/files/pos/t8900.scala b/test/files/pos/t8900.scala new file mode 100644 index 0000000000..376bd786f2 --- /dev/null +++ b/test/files/pos/t8900.scala @@ -0,0 +1,11 @@ +package foo +package lambdaking + +class Test { + def byname(b: => Any) = ??? + def foo: Any = { + def bar: Any = { + byname(bar) + } + } +} diff --git a/test/files/pos/t8934a/A_1.scala b/test/files/pos/t8934a/A_1.scala new file mode 100644 index 0000000000..6c1f29d030 --- /dev/null +++ b/test/files/pos/t8934a/A_1.scala @@ -0,0 +1,18 @@ +import language.experimental.macros +import reflect.macros.whitebox.Context + +object Unapply { + def impl1(c: Context)(a: c.Tree): c.Tree = { + import c.universe._ + q"(new { def unapply[T](a: String): Option[(Int, String)] = ??? }).unapply($a)" + } + def unapply(a: Any): Any = macro impl1 +} + +object UnapplySeq { + def impl1(c: Context)(a: c.Tree): c.Tree = { + import c.universe._ + q"(new { def unapplySeq[T](a: String): Option[(Int, Seq[String])] = ??? }).unapplySeq($a)" + } + def unapplySeq(a: Any): Any = macro impl1 +} diff --git a/test/files/pos/t8934a/Test_2.flags b/test/files/pos/t8934a/Test_2.flags new file mode 100644 index 0000000000..618dfe2b75 --- /dev/null +++ b/test/files/pos/t8934a/Test_2.flags @@ -0,0 +1 @@ +-Ystop-after:typer -Ymacro-expand:discard -nowarn diff --git a/test/files/pos/t8934a/Test_2.scala b/test/files/pos/t8934a/Test_2.scala new file mode 100644 index 0000000000..e1792ed3c5 --- /dev/null +++ b/test/files/pos/t8934a/Test_2.scala @@ -0,0 +1,12 @@ +object Test { + "" match { + case Unapply(a, b) => + a: Int + b: String + case UnapplySeq(a, b1, b2) => + a: Int + b1: String + b2: String + } +} +// These used to fail `too many patterns` under -Ymacro-expand:discard diff --git a/test/files/pos/t8947/Client_2.scala b/test/files/pos/t8947/Client_2.scala new file mode 100644 index 0000000000..1a5082a2f9 --- /dev/null +++ b/test/files/pos/t8947/Client_2.scala @@ -0,0 +1 @@ +object Test { X.extractor }
\ No newline at end of file diff --git a/test/files/pos/t8947/Macro_1.scala b/test/files/pos/t8947/Macro_1.scala new file mode 100644 index 0000000000..4a5de3decb --- /dev/null +++ b/test/files/pos/t8947/Macro_1.scala @@ -0,0 +1,41 @@ +import language.experimental.macros +import scala.reflect.macros._ +import blackbox.Context + +object X { + + def classTagOrNull[T](implicit t: reflect.ClassTag[T] = null) = t + // the failed search for ClassTag[T] does not issue a visible + // error as we fall back to the default argument. But, the + // macro engine things we have expanded the macro `materializeClassTag[D]()` + // to `EmptyTree`, and then attaches a backreference from the expansion + // to the expandee. This is the `MacroExpansionAttachment` tree attachment. + def foo[D] = classTagOrNull[D] + + def extractor: Any = macro X.extractorMacro + def extractorMacro(c: Context): c.Expr[Any] = { + // Later, in reify, an unrelated use of `EmptyTree` in the AST representing + // the argument is now treated as a macro expansion which should be rolled + // back in the tree we reify! This ends up generating a call to `implicitly` + // which leads to an ambiguous error. + // + // Any macro call that expands to EmptyTree could have triggered this problem. + c.universe.reify(new { def something(data: Any) = ??? }) + } + + // Workarounds: + // + // 1. Use quasiquotes rather than `reify`. (But, beware to fully qualify all references, e.g. `_root_.scala.Predef.???`) + // 2. Avoid failed ClassTag lookups (e.g. in the original bug report, annotate the type argument to `map`) + // 3. In the macro implementation, just before calling the `reify` macro, you could call another macro + // + // def prepareReify = macro prepareReifyImpl + // def prepareReifyImpl(c: Context) = { + // val symtab = c.universe.asInstanceOf[reflect.internal.SymbolTable] + // symtab.EmptyTree.setAttachments(symtab.NoPosition) + // } + // + // To make this visible to the macro implementaiton, it will need to be compiled in an earlier stage, + // e.g a separate SBT sub-project. + +} diff --git a/test/files/pos/t8954.flags b/test/files/pos/t8954.flags new file mode 100644 index 0000000000..7de3c0f3ee --- /dev/null +++ b/test/files/pos/t8954.flags @@ -0,0 +1 @@ +-Xfatal-warnings -deprecation diff --git a/test/files/pos/t8954/t1.scala b/test/files/pos/t8954/t1.scala new file mode 100644 index 0000000000..3986d9f3b5 --- /dev/null +++ b/test/files/pos/t8954/t1.scala @@ -0,0 +1,13 @@ +package scala.foo + +// 1. a class about to be made final +@deprecatedInheritance class A { + def foo(): Unit = ??? +} + +// 1.1: +// - no inheritance warning because same file +// - no "override non-deprecated member" because @deprecatedInheritance +class B2 extends A { + @deprecated("","") override def foo(): Unit = ??? +} diff --git a/test/files/pos/t8954/t2.scala b/test/files/pos/t8954/t2.scala new file mode 100644 index 0000000000..4def127832 --- /dev/null +++ b/test/files/pos/t8954/t2.scala @@ -0,0 +1,39 @@ +package scala.foo + +// 1.2 deprecated children should be fine... +@deprecated("", "") class B extends A { + + // 1.3 and shouldn't trigger the + // "overriding non-deprecated parent" warning + override def foo(): Unit = ??? +} + +@deprecated("","") class F { + // 1.4 a class inside a deprecated class should work too + class G extends A +} + +// 2. a method about to be made final +class C { + @deprecatedOverriding def foo(): Unit = ??? +} + +// 2.1 overriding with a deprecated def should be fine +// and also shoudln't trigger the "deprecation is useless" +// warning +class D extends C { + @deprecated("","") override def foo(): Unit = ??? +} + +// 2.2 overriding from a deprecated class should be fine +@deprecated("","") class E extends C { + override def foo(): Unit = ??? +} + +// 2.3 overriding from deeper inside a deprecated class +// should work too +@deprecated("","") class H { + class I extends C { + override def foo(): Unit = ??? + } +} diff --git a/test/files/pos/t8962.scala b/test/files/pos/t8962.scala new file mode 100644 index 0000000000..4331c154ba --- /dev/null +++ b/test/files/pos/t8962.scala @@ -0,0 +1,31 @@ +package test.nestedcov + +sealed abstract class Outer[+A] +case class Let[+A](expr: Outer[Inner[A]]) extends Outer[A] + +sealed abstract class Inner[+A] + +sealed abstract class Outer2[+A, +B] +case class Let2[+A](expr: Outer2[Inner2[A], A]) extends Outer2[A, A] + +sealed abstract class Inner2[+A] + +sealed abstract class Outer3[+A, +B] +case class Let3[+A](expr: Outer3[A, A]) extends Outer3[A, A] + +object NestedCov { + def run[A](nc: Outer[A]) = nc match { + case Let(expr) => + expr : Outer[Inner[A]] + } + + def run2[A](nc: Outer2[A, A]) = nc match { + case Let2(expr) => + expr : Outer2[Inner2[A], A] + } + + def run3[A](nc: Outer3[A, A]) = nc match { + case Let3(expr) => + expr : Outer3[A, A] + } +} diff --git a/test/files/pos/t8965.flags b/test/files/pos/t8965.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/pos/t8965.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/pos/t8965.scala b/test/files/pos/t8965.scala new file mode 100644 index 0000000000..4f39330f4e --- /dev/null +++ b/test/files/pos/t8965.scala @@ -0,0 +1,7 @@ +class A { + def f(x: Any with AnyRef, y: Any with AnyRef) = x eq y + // a.scala:2: warning: Any and Any are unrelated: they will most likely never compare equal + // def f(x: Any with AnyRef, y: Any with AnyRef) = x eq y + // ^ + // one warning found +} diff --git a/test/files/pos/t8999.flags b/test/files/pos/t8999.flags new file mode 100644 index 0000000000..0f96f1f872 --- /dev/null +++ b/test/files/pos/t8999.flags @@ -0,0 +1 @@ +-nowarn
\ No newline at end of file diff --git a/test/files/pos/t8999.scala b/test/files/pos/t8999.scala new file mode 100644 index 0000000000..99c4b2ad84 --- /dev/null +++ b/test/files/pos/t8999.scala @@ -0,0 +1,271 @@ +object Types { + + abstract sealed class Type + + case object AnyType extends Type + + case object NothingType extends Type + + case object UndefType extends Type + + case object BooleanType extends Type + + case object IntType extends Type + + case object LongType extends Type + + case object FloatType extends Type + + case object DoubleType extends Type + + case object StringType extends Type + + case object NullType extends Type + + sealed abstract class ReferenceType extends Type + + final case class ClassType(className: String) extends ReferenceType + + final case class ArrayType(baseClassName: String, dimensions: Int) extends ReferenceType + + final case class RecordType(fields: List[RecordType.Field]) extends Type + + object RecordType { + final case class Field(name: String, originalName: Option[String], + tpe: Type, mutable: Boolean) + } + + case object NoType extends Type + +} + + +sealed abstract class ClassKind + +object ClassKind { + + case object Class extends ClassKind + + case object ModuleClass extends ClassKind + + case object Interface extends ClassKind + + case object RawJSType extends ClassKind + + case object HijackedClass extends ClassKind + + case object TraitImpl extends ClassKind + +} + +object Trees { + + import Types._ + + abstract sealed class Tree + + case object EmptyTree extends Tree + + sealed trait PropertyName + case class Ident(name: String, originalName: Option[String]) extends PropertyName + object Ident { + def apply(name: String): Ident = + new Ident(name, Some(name)) + } + + case class VarDef(name: Ident, vtpe: Type, mutable: Boolean, rhs: Tree) extends Tree + + case class ParamDef(name: Ident, ptpe: Type, mutable: Boolean) extends Tree + + case class Skip() extends Tree + + class Block private(val stats: List[Tree]) extends Tree + + object Block { + def unapply(block: Block): Some[List[Tree]] = Some(block.stats) + } + + case class Labeled(label: Ident, tpe: Type, body: Tree) extends Tree + + case class Assign(lhs: Tree, rhs: Tree) extends Tree + + case class Return(expr: Tree, label: Option[Ident] = None) extends Tree + + case class If(cond: Tree, thenp: Tree, elsep: Tree) extends Tree + + case class While(cond: Tree, body: Tree, label: Option[Ident] = None) extends Tree + + case class DoWhile(body: Tree, cond: Tree, label: Option[Ident] = None) extends Tree + + case class Try(block: Tree, errVar: Ident, handler: Tree, finalizer: Tree) extends Tree + + case class Throw(expr: Tree) extends Tree + + case class Continue(label: Option[Ident] = None) extends Tree + + case class Match(selector: Tree, cases: List[(List[Literal], Tree)], default: Tree) extends Tree + + case class Debugger() extends Tree + + case class New(cls: ClassType, ctor: Ident, args: List[Tree]) extends Tree + + case class LoadModule(cls: ClassType) extends Tree + + case class StoreModule(cls: ClassType, value: Tree) extends Tree + + case class Select(qualifier: Tree, item: Ident, mutable: Boolean) extends Tree + + case class Apply(receiver: Tree, method: Ident, args: List[Tree]) extends Tree + + case class StaticApply(receiver: Tree, cls: ClassType, method: Ident, args: List[Tree]) extends Tree + + case class TraitImplApply(impl: ClassType, method: Ident, args: List[Tree]) extends Tree + + case class UnaryOp(op: Int, lhs: Tree) extends Tree + + case class BinaryOp(op: Int, lhs: Tree, rhs: Tree) extends Tree + + case class NewArray(tpe: ArrayType, lengths: List[Tree]) extends Tree + + case class ArrayValue(tpe: ArrayType, elems: List[Tree]) extends Tree + + case class ArrayLength(array: Tree) extends Tree + + case class ArraySelect(array: Tree, index: Tree) extends Tree + + case class RecordValue(tpe: RecordType, elems: List[Tree]) extends Tree + + case class IsInstanceOf(expr: Tree, cls: ReferenceType) extends Tree + + case class AsInstanceOf(expr: Tree, cls: ReferenceType) extends Tree + + case class Unbox(expr: Tree, charCode: Char) extends Tree + + case class GetClass(expr: Tree) extends Tree + + case class CallHelper(helper: String, args: List[Tree]) extends Tree + + case class JSNew(ctor: Tree, args: List[Tree]) extends Tree + + case class JSDotSelect(qualifier: Tree, item: Ident) extends Tree + + case class JSBracketSelect(qualifier: Tree, item: Tree) extends Tree + + case class JSFunctionApply(fun: Tree, args: List[Tree]) extends Tree + + case class JSDotMethodApply(receiver: Tree, method: Ident, args: List[Tree]) extends Tree + + case class JSBracketMethodApply(receiver: Tree, method: Tree, args: List[Tree]) extends Tree + + case class JSDelete(prop: Tree) extends Tree + + case class JSUnaryOp(op: String, lhs: Tree) extends Tree + + case class JSBinaryOp(op: String, lhs: Tree, rhs: Tree) extends Tree + + case class JSArrayConstr(items: List[Tree]) extends Tree + + case class JSObjectConstr(fields: List[(PropertyName, Tree)]) extends Tree + + case class JSEnvInfo() extends Tree + + sealed trait Literal extends Tree + + case class Undefined() extends Literal + + case class UndefinedParam() extends Literal + + case class Null() extends Literal + + case class BooleanLiteral(value: Boolean) extends Literal + + case class IntLiteral(value: Int) extends Literal + + case class LongLiteral(value: Long) extends Literal + + case class FloatLiteral(value: Float) extends Literal + + case class DoubleLiteral(value: Double) extends Literal + + case class StringLiteral(value: String) extends Literal with PropertyName + + case class ClassOf(cls: ReferenceType) extends Literal + + case class VarRef(ident: Ident, mutable: Boolean) extends Tree + + case class This() extends Tree + + case class Closure(captureParams: List[ParamDef], params: List[ParamDef], + body: Tree, captureValues: List[Tree]) extends Tree + + case class ClassDef(name: Ident, kind: ClassKind, parent: Option[Ident], ancestors: List[Ident], defs: List[Tree]) extends Tree + + case class MethodDef(name: PropertyName, args: List[ParamDef], resultType: Type, body: Tree) extends Tree + + case class PropertyDef(name: PropertyName, getterBody: Tree, setterArg: ParamDef, setterBody: Tree) extends Tree + + case class ConstructorExportDef(name: String, args: List[ParamDef], body: Tree) extends Tree + + case class ModuleExportDef(fullName: String) extends Tree + + final class TreeHash(val treeHash: Array[Byte], val posHash: Array[Byte]) +} + +object Main { + import Trees._ + import Types._ + + private def transform(tree: Tree) = { + val ObjectClass = "O" + tree match { + case VarDef(_, _, _, rhs) => + case tree: Block => + case Labeled(ident@Ident(label, _), tpe, body) => + case Assign(lhs, rhs) => + case Return(expr, optLabel) => + case If(cond, thenp, elsep) => + case While(cond, body, optLabel) => + case DoWhile(body, cond, None) => + case Try(block, errVar, EmptyTree, finalizer) => + case Try(block, errVar@Ident(name, originalName), handler, finalizer) => + case Throw(expr) => + case Continue(optLabel) => + case Match(selector, cases, default) => + case New(cls, ctor, args) => + case StoreModule(cls, value) => + case tree: Select => + case tree: Apply => + case tree: StaticApply => + case tree: TraitImplApply => + case tree@UnaryOp(_, arg) => + case tree@BinaryOp(op, lhs, rhs) => + case NewArray(tpe, lengths) => + case ArrayValue(tpe, elems) => + case ArrayLength(array) => + case ArraySelect(array, index) => + case RecordValue(tpe, elems) => + case IsInstanceOf(expr, ClassType(ObjectClass)) => + case IsInstanceOf(expr, tpe) => + case AsInstanceOf(expr, ClassType(ObjectClass)) => + case AsInstanceOf(expr, cls) => + case Unbox(arg, charCode) => + case GetClass(expr) => + case JSNew(ctor, args) => + case JSDotSelect(qualifier, item) => + case JSBracketSelect(qualifier, item) => + case tree: JSFunctionApply => + case JSDotMethodApply(receiver, method, args) => + case JSBracketMethodApply(receiver, method, args) => + case JSDelete(JSDotSelect(obj, prop)) => + case JSDelete(JSBracketSelect(obj, prop)) => + case JSUnaryOp(op, lhs) => + case JSBinaryOp(op, lhs, rhs) => + case JSArrayConstr(items) => + case JSObjectConstr(fields) => + case _: VarRef | _: This => + case Closure(captureParams, params, body, captureValues) => + case _: Skip | _: Debugger | _: LoadModule | + _: JSEnvInfo | _: Literal | EmptyTree => + } + } +}
\ No newline at end of file diff --git a/test/files/pos/t9008.scala b/test/files/pos/t9008.scala new file mode 100644 index 0000000000..d11b8604f2 --- /dev/null +++ b/test/files/pos/t9008.scala @@ -0,0 +1,5 @@ +trait Monad[M[_]] + +object Test { + def x: Monad[M forSome { type M[_] }] = ??? +} diff --git a/test/files/pos/t9018.scala b/test/files/pos/t9018.scala new file mode 100644 index 0000000000..7fb4cf21b3 --- /dev/null +++ b/test/files/pos/t9018.scala @@ -0,0 +1,16 @@ +object TestObject { + + def m(i: Int): AnyRef = i match { + case 0 => new C() + case 1 => Some(E.A).getOrElse("") + } + + class C extends Ordered[C] { + def compare(that: C): Int = ??? + } + + object E extends Enumeration { + type CharacterClass = Value + val A = Value + } +} diff --git a/test/files/pos/t9020.flags b/test/files/pos/t9020.flags new file mode 100644 index 0000000000..efb2dd3e6f --- /dev/null +++ b/test/files/pos/t9020.flags @@ -0,0 +1 @@ +-Ywarn-value-discard -Xfatal-warnings diff --git a/test/files/pos/t9020.scala b/test/files/pos/t9020.scala new file mode 100644 index 0000000000..16e31e2572 --- /dev/null +++ b/test/files/pos/t9020.scala @@ -0,0 +1,10 @@ +trait ValueDiscard[@specialized U] { + def u: U +} +/* Was: +scalac-hash v2.11.5 -Ywarn-value-discard test/files/pos/t9020.scala +test/files/pos/t9020.scala:2: warning: discarded non-Unit value + def u: U + ^ +one warning found +*/ diff --git a/test/files/pos/t9050.scala b/test/files/pos/t9050.scala new file mode 100644 index 0000000000..b1ab09f901 --- /dev/null +++ b/test/files/pos/t9050.scala @@ -0,0 +1,13 @@ +final class Mu[F](val value: Any) extends AnyVal { + def cata(f: F) { + // crash + ((y: Mu[F]) => y.cata(f)) + // crash + def foo(x : Mu[F]) = x.cata(f) + + // // okay + def x: Mu[F] = ??? + (() => x.cata(f)) + assert(true, cata(f)) + } +} diff --git a/test/files/pos/t9086.scala b/test/files/pos/t9086.scala new file mode 100644 index 0000000000..fba34ee226 --- /dev/null +++ b/test/files/pos/t9086.scala @@ -0,0 +1,8 @@ +class X[A](a: A) +object Test { + implicit val ImplicitBoolean: Boolean = true + def local = { + implicit object X extends X({ implicitly[Boolean] ; "" }) + implicitly[X[String]] // failed in 2.11.5 + } +} diff --git a/test/files/pos/t9111-inliner-workaround.flags b/test/files/pos/t9111-inliner-workaround.flags new file mode 100644 index 0000000000..63b5558cfd --- /dev/null +++ b/test/files/pos/t9111-inliner-workaround.flags @@ -0,0 +1 @@ +-Ybackend:GenBCode -Yopt:l:classpath
\ No newline at end of file diff --git a/test/files/pos/t9111-inliner-workaround/A_1.java b/test/files/pos/t9111-inliner-workaround/A_1.java new file mode 100644 index 0000000000..bc60b68ea6 --- /dev/null +++ b/test/files/pos/t9111-inliner-workaround/A_1.java @@ -0,0 +1,13 @@ +public class A_1 { + public static class T { } + + public static class Inner { + public static class T { } + + public void foo(T t) { } + + public T t = null; + + public class Deeper extends T { } + } +} diff --git a/test/files/pos/t9111-inliner-workaround/Test_1.scala b/test/files/pos/t9111-inliner-workaround/Test_1.scala new file mode 100644 index 0000000000..1a00fff833 --- /dev/null +++ b/test/files/pos/t9111-inliner-workaround/Test_1.scala @@ -0,0 +1,10 @@ +object Test extends App { + println(new A_1.Inner()) + + // Accessing foo or Deeper triggers the error of SI-9111. + // However, when not referring to those definitions, compilation should + // succeed, also if the inliner is enabled. + + // println(i.foo(null)) + // new i.Deeper() +} diff --git a/test/files/pos/t9116.scala b/test/files/pos/t9116.scala new file mode 100644 index 0000000000..16b04c2e6b --- /dev/null +++ b/test/files/pos/t9116.scala @@ -0,0 +1,7 @@ + +trait X { + List(1, 2, 3).toSet.subsets.map(_.toList) // ok now + + List(1, 2, 3).toSet.subsets().map(_.toList) // now also + List(1, 2, 3).toSet.subsets(2).map(_.toList) // still ok +} diff --git a/test/files/pos/t9123.flags b/test/files/pos/t9123.flags new file mode 100644 index 0000000000..c16e2f71dc --- /dev/null +++ b/test/files/pos/t9123.flags @@ -0,0 +1 @@ +-optimize -Ydelambdafy:method diff --git a/test/files/pos/t9123.scala b/test/files/pos/t9123.scala new file mode 100644 index 0000000000..22d55b4351 --- /dev/null +++ b/test/files/pos/t9123.scala @@ -0,0 +1,10 @@ +trait Setting { + type T + def value: T +} + +object Test { + def test(x: Some[Setting]) = x match { + case Some(dep) => Some(dep.value) map (_ => true) + } +} diff --git a/test/files/pos/t9135.scala b/test/files/pos/t9135.scala new file mode 100644 index 0000000000..1e2c97baf9 --- /dev/null +++ b/test/files/pos/t9135.scala @@ -0,0 +1,16 @@ + +class Free[A] { + + + this match { + case a @ Gosub() => gosub(a.a)(x => gosub(???)(???)) + } + def gosub[A, B](a0: Free[A])(f0: A => Any): Free[B] = ??? +} + + + + case class Gosub[B]() extends Free[B] { + type C + def a: Free[C] = ??? + } diff --git a/test/files/pos/t9157.scala b/test/files/pos/t9157.scala new file mode 100644 index 0000000000..e178b5d84d --- /dev/null +++ b/test/files/pos/t9157.scala @@ -0,0 +1,13 @@ +trait Flow[-In, +Out] { + type Repr[+O] <: Flow[In, O] + def map: Repr[String] +} + +class Test { + // typechecking was exponentially slow wrt the number of projections here. + def slowFlow( + f: Flow[String,String]#Repr[String]#Repr[String]#Repr[String]#Repr[String]#Repr[String]#Repr[String]#Repr[String]#Repr[String]#Repr[String]#Repr[String]#Repr[String] + ) = { + f.map + } +} diff --git a/test/files/pos/t9181.flags b/test/files/pos/t9181.flags new file mode 100644 index 0000000000..0f96f1f872 --- /dev/null +++ b/test/files/pos/t9181.flags @@ -0,0 +1 @@ +-nowarn
\ No newline at end of file diff --git a/test/files/pos/t9181.scala b/test/files/pos/t9181.scala new file mode 100644 index 0000000000..2edf6fe4a3 --- /dev/null +++ b/test/files/pos/t9181.scala @@ -0,0 +1,806 @@ +sealed trait C +case object C1 extends C +case object C2 extends C +case object C3 extends C +case object C4 extends C +case object C5 extends C +case object C6 extends C +case object C7 extends C +case object C8 extends C +case object C9 extends C +case object C10 extends C +case object C11 extends C +case object C12 extends C +case object C13 extends C +case object C14 extends C +case object C15 extends C +case object C16 extends C +case object C17 extends C +case object C18 extends C +case object C19 extends C +case object C20 extends C +case object C21 extends C +case object C22 extends C +case object C23 extends C +case object C24 extends C +case object C25 extends C +case object C26 extends C +case object C27 extends C +case object C28 extends C +case object C29 extends C +case object C30 extends C +case object C31 extends C +case object C32 extends C +case object C33 extends C +case object C34 extends C +case object C35 extends C +case object C36 extends C +case object C37 extends C +case object C38 extends C +case object C39 extends C +case object C40 extends C +case object C41 extends C +case object C42 extends C +case object C43 extends C +case object C44 extends C +case object C45 extends C +case object C46 extends C +case object C47 extends C +case object C48 extends C +case object C49 extends C +case object C50 extends C +case object C51 extends C +case object C52 extends C +case object C53 extends C +case object C54 extends C +case object C55 extends C +case object C56 extends C +case object C57 extends C +case object C58 extends C +case object C59 extends C +case object C60 extends C +case object C61 extends C +case object C62 extends C +case object C63 extends C +case object C64 extends C +case object C65 extends C +case object C66 extends C +case object C67 extends C +case object C68 extends C +case object C69 extends C +case object C70 extends C +case object C71 extends C +case object C72 extends C +case object C73 extends C +case object C74 extends C +case object C75 extends C +case object C76 extends C +case object C77 extends C +case object C78 extends C +case object C79 extends C +case object C80 extends C +case object C81 extends C +case object C82 extends C +case object C83 extends C +case object C84 extends C +case object C85 extends C +case object C86 extends C +case object C87 extends C +case object C88 extends C +case object C89 extends C +case object C90 extends C +case object C91 extends C +case object C92 extends C +case object C93 extends C +case object C94 extends C +case object C95 extends C +case object C96 extends C +case object C97 extends C +case object C98 extends C +case object C99 extends C +case object C100 extends C +case object C101 extends C +case object C102 extends C +case object C103 extends C +case object C104 extends C +case object C105 extends C +case object C106 extends C +case object C107 extends C +case object C108 extends C +case object C109 extends C +case object C110 extends C +case object C111 extends C +case object C112 extends C +case object C113 extends C +case object C114 extends C +case object C115 extends C +case object C116 extends C +case object C117 extends C +case object C118 extends C +case object C119 extends C +case object C120 extends C +case object C121 extends C +case object C122 extends C +case object C123 extends C +case object C124 extends C +case object C125 extends C +case object C126 extends C +case object C127 extends C +case object C128 extends C +case object C129 extends C +case object C130 extends C +case object C131 extends C +case object C132 extends C +case object C133 extends C +case object C134 extends C +case object C135 extends C +case object C136 extends C +case object C137 extends C +case object C138 extends C +case object C139 extends C +case object C140 extends C +case object C141 extends C +case object C142 extends C +case object C143 extends C +case object C144 extends C +case object C145 extends C +case object C146 extends C +case object C147 extends C +case object C148 extends C +case object C149 extends C +case object C150 extends C +case object C151 extends C +case object C152 extends C +case object C153 extends C +case object C154 extends C +case object C155 extends C +case object C156 extends C +case object C157 extends C +case object C158 extends C +case object C159 extends C +case object C160 extends C +case object C161 extends C +case object C162 extends C +case object C163 extends C +case object C164 extends C +case object C165 extends C +case object C166 extends C +case object C167 extends C +case object C168 extends C +case object C169 extends C +case object C170 extends C +case object C171 extends C +case object C172 extends C +case object C173 extends C +case object C174 extends C +case object C175 extends C +case object C176 extends C +case object C177 extends C +case object C178 extends C +case object C179 extends C +case object C180 extends C +case object C181 extends C +case object C182 extends C +case object C183 extends C +case object C184 extends C +case object C185 extends C +case object C186 extends C +case object C187 extends C +case object C188 extends C +case object C189 extends C +case object C190 extends C +case object C191 extends C +case object C192 extends C +case object C193 extends C +case object C194 extends C +case object C195 extends C +case object C196 extends C +case object C197 extends C +case object C198 extends C +case object C199 extends C +case object C200 extends C +case object C201 extends C +case object C202 extends C +case object C203 extends C +case object C204 extends C +case object C205 extends C +case object C206 extends C +case object C207 extends C +case object C208 extends C +case object C209 extends C +case object C210 extends C +case object C211 extends C +case object C212 extends C +case object C213 extends C +case object C214 extends C +case object C215 extends C +case object C216 extends C +case object C217 extends C +case object C218 extends C +case object C219 extends C +case object C220 extends C +case object C221 extends C +case object C222 extends C +case object C223 extends C +case object C224 extends C +case object C225 extends C +case object C226 extends C +case object C227 extends C +case object C228 extends C +case object C229 extends C +case object C230 extends C +case object C231 extends C +case object C232 extends C +case object C233 extends C +case object C234 extends C +case object C235 extends C +case object C236 extends C +case object C237 extends C +case object C238 extends C +case object C239 extends C +case object C240 extends C +case object C241 extends C +case object C242 extends C +case object C243 extends C +case object C244 extends C +case object C245 extends C +case object C246 extends C +case object C247 extends C +case object C248 extends C +case object C249 extends C +case object C250 extends C +case object C251 extends C +case object C252 extends C +case object C253 extends C +case object C254 extends C +case object C255 extends C +case object C256 extends C +case object C257 extends C +case object C258 extends C +case object C259 extends C +case object C260 extends C +case object C261 extends C +case object C262 extends C +case object C263 extends C +case object C264 extends C +case object C265 extends C +case object C266 extends C +case object C267 extends C +case object C268 extends C +case object C269 extends C +case object C270 extends C +case object C271 extends C +case object C272 extends C +case object C273 extends C +case object C274 extends C +case object C275 extends C +case object C276 extends C +case object C277 extends C +case object C278 extends C +case object C279 extends C +case object C280 extends C +case object C281 extends C +case object C282 extends C +case object C283 extends C +case object C284 extends C +case object C285 extends C +case object C286 extends C +case object C287 extends C +case object C288 extends C +case object C289 extends C +case object C290 extends C +case object C291 extends C +case object C292 extends C +case object C293 extends C +case object C294 extends C +case object C295 extends C +case object C296 extends C +case object C297 extends C +case object C298 extends C +case object C299 extends C +case object C300 extends C +case object C301 extends C +case object C302 extends C +case object C303 extends C +case object C304 extends C +case object C305 extends C +case object C306 extends C +case object C307 extends C +case object C308 extends C +case object C309 extends C +case object C310 extends C +case object C311 extends C +case object C312 extends C +case object C313 extends C +case object C314 extends C +case object C315 extends C +case object C316 extends C +case object C317 extends C +case object C318 extends C +case object C319 extends C +case object C320 extends C +case object C321 extends C +case object C322 extends C +case object C323 extends C +case object C324 extends C +case object C325 extends C +case object C326 extends C +case object C327 extends C +case object C328 extends C +case object C329 extends C +case object C330 extends C +case object C331 extends C +case object C332 extends C +case object C333 extends C +case object C334 extends C +case object C335 extends C +case object C336 extends C +case object C337 extends C +case object C338 extends C +case object C339 extends C +case object C340 extends C +case object C341 extends C +case object C342 extends C +case object C343 extends C +case object C344 extends C +case object C345 extends C +case object C346 extends C +case object C347 extends C +case object C348 extends C +case object C349 extends C +case object C350 extends C +case object C351 extends C +case object C352 extends C +case object C353 extends C +case object C354 extends C +case object C355 extends C +case object C356 extends C +case object C357 extends C +case object C358 extends C +case object C359 extends C +case object C360 extends C +case object C361 extends C +case object C362 extends C +case object C363 extends C +case object C364 extends C +case object C365 extends C +case object C366 extends C +case object C367 extends C +case object C368 extends C +case object C369 extends C +case object C370 extends C +case object C371 extends C +case object C372 extends C +case object C373 extends C +case object C374 extends C +case object C375 extends C +case object C376 extends C +case object C377 extends C +case object C378 extends C +case object C379 extends C +case object C380 extends C +case object C381 extends C +case object C382 extends C +case object C383 extends C +case object C384 extends C +case object C385 extends C +case object C386 extends C +case object C387 extends C +case object C388 extends C +case object C389 extends C +case object C390 extends C +case object C391 extends C +case object C392 extends C +case object C393 extends C +case object C394 extends C +case object C395 extends C +case object C396 extends C +case object C397 extends C +case object C398 extends C +case object C399 extends C +case object C400 extends C + +object M { + def f(c: C): Int = c match { + case C1 => 1 + case C2 => 2 + case C3 => 3 + case C4 => 4 + case C5 => 5 + case C6 => 6 + case C7 => 7 + case C8 => 8 + case C9 => 9 + case C10 => 10 + case C11 => 11 + case C12 => 12 + case C13 => 13 + case C14 => 14 + case C15 => 15 + case C16 => 16 + case C17 => 17 + case C18 => 18 + case C19 => 19 + case C20 => 20 + case C21 => 21 + case C22 => 22 + case C23 => 23 + case C24 => 24 + case C25 => 25 + case C26 => 26 + case C27 => 27 + case C28 => 28 + case C29 => 29 + case C30 => 30 + case C31 => 31 + case C32 => 32 + case C33 => 33 + case C34 => 34 + case C35 => 35 + case C36 => 36 + case C37 => 37 + case C38 => 38 + case C39 => 39 + case C40 => 40 + case C41 => 41 + case C42 => 42 + case C43 => 43 + case C44 => 44 + case C45 => 45 + case C46 => 46 + case C47 => 47 + case C48 => 48 + case C49 => 49 + case C50 => 50 + case C51 => 51 + case C52 => 52 + case C53 => 53 + case C54 => 54 + case C55 => 55 + case C56 => 56 + case C57 => 57 + case C58 => 58 + case C59 => 59 + case C60 => 60 + case C61 => 61 + case C62 => 62 + case C63 => 63 + case C64 => 64 + case C65 => 65 + case C66 => 66 + case C67 => 67 + case C68 => 68 + case C69 => 69 + case C70 => 70 + case C71 => 71 + case C72 => 72 + case C73 => 73 + case C74 => 74 + case C75 => 75 + case C76 => 76 + case C77 => 77 + case C78 => 78 + case C79 => 79 + case C80 => 80 + case C81 => 81 + case C82 => 82 + case C83 => 83 + case C84 => 84 + case C85 => 85 + case C86 => 86 + case C87 => 87 + case C88 => 88 + case C89 => 89 + case C90 => 90 + case C91 => 91 + case C92 => 92 + case C93 => 93 + case C94 => 94 + case C95 => 95 + case C96 => 96 + case C97 => 97 + case C98 => 98 + case C99 => 99 + case C100 => 100 + case C101 => 101 + case C102 => 102 + case C103 => 103 + case C104 => 104 + case C105 => 105 + case C106 => 106 + case C107 => 107 + case C108 => 108 + case C109 => 109 + case C110 => 110 + case C111 => 111 + case C112 => 112 + case C113 => 113 + case C114 => 114 + case C115 => 115 + case C116 => 116 + case C117 => 117 + case C118 => 118 + case C119 => 119 + case C120 => 120 + case C121 => 121 + case C122 => 122 + case C123 => 123 + case C124 => 124 + case C125 => 125 + case C126 => 126 + case C127 => 127 + case C128 => 128 + case C129 => 129 + case C130 => 130 + case C131 => 131 + case C132 => 132 + case C133 => 133 + case C134 => 134 + case C135 => 135 + case C136 => 136 + case C137 => 137 + case C138 => 138 + case C139 => 139 + case C140 => 140 + case C141 => 141 + case C142 => 142 + case C143 => 143 + case C144 => 144 + case C145 => 145 + case C146 => 146 + case C147 => 147 + case C148 => 148 + case C149 => 149 + case C150 => 150 + case C151 => 151 + case C152 => 152 + case C153 => 153 + case C154 => 154 + case C155 => 155 + case C156 => 156 + case C157 => 157 + case C158 => 158 + case C159 => 159 + case C160 => 160 + case C161 => 161 + case C162 => 162 + case C163 => 163 + case C164 => 164 + case C165 => 165 + case C166 => 166 + case C167 => 167 + case C168 => 168 + case C169 => 169 + case C170 => 170 + case C171 => 171 + case C172 => 172 + case C173 => 173 + case C174 => 174 + case C175 => 175 + case C176 => 176 + case C177 => 177 + case C178 => 178 + case C179 => 179 + case C180 => 180 + case C181 => 181 + case C182 => 182 + case C183 => 183 + case C184 => 184 + case C185 => 185 + case C186 => 186 + case C187 => 187 + case C188 => 188 + case C189 => 189 + case C190 => 190 + case C191 => 191 + case C192 => 192 + case C193 => 193 + case C194 => 194 + case C195 => 195 + case C196 => 196 + case C197 => 197 + case C198 => 198 + case C199 => 199 + case C200 => 200 + case C201 => 201 + case C202 => 202 + case C203 => 203 + case C204 => 204 + case C205 => 205 + case C206 => 206 + case C207 => 207 + case C208 => 208 + case C209 => 209 + case C210 => 210 + case C211 => 211 + case C212 => 212 + case C213 => 213 + case C214 => 214 + case C215 => 215 + case C216 => 216 + case C217 => 217 + case C218 => 218 + case C219 => 219 + case C220 => 220 + case C221 => 221 + case C222 => 222 + case C223 => 223 + case C224 => 224 + case C225 => 225 + case C226 => 226 + case C227 => 227 + case C228 => 228 + case C229 => 229 + case C230 => 230 + case C231 => 231 + case C232 => 232 + case C233 => 233 + case C234 => 234 + case C235 => 235 + case C236 => 236 + case C237 => 237 + case C238 => 238 + case C239 => 239 + case C240 => 240 + case C241 => 241 + case C242 => 242 + case C243 => 243 + case C244 => 244 + case C245 => 245 + case C246 => 246 + case C247 => 247 + case C248 => 248 + case C249 => 249 + case C250 => 250 + case C251 => 251 + case C252 => 252 + case C253 => 253 + case C254 => 254 + case C255 => 255 + case C256 => 256 + case C257 => 257 + case C258 => 258 + case C259 => 259 + case C260 => 260 + case C261 => 261 + case C262 => 262 + case C263 => 263 + case C264 => 264 + case C265 => 265 + case C266 => 266 + case C267 => 267 + case C268 => 268 + case C269 => 269 + case C270 => 270 + case C271 => 271 + case C272 => 272 + case C273 => 273 + case C274 => 274 + case C275 => 275 + case C276 => 276 + case C277 => 277 + case C278 => 278 + case C279 => 279 + case C280 => 280 + case C281 => 281 + case C282 => 282 + case C283 => 283 + case C284 => 284 + case C285 => 285 + case C286 => 286 + case C287 => 287 + case C288 => 288 + case C289 => 289 + case C290 => 290 + case C291 => 291 + case C292 => 292 + case C293 => 293 + case C294 => 294 + case C295 => 295 + case C296 => 296 + case C297 => 297 + case C298 => 298 + case C299 => 299 + case C300 => 300 + case C301 => 301 + case C302 => 302 + case C303 => 303 + case C304 => 304 + case C305 => 305 + case C306 => 306 + case C307 => 307 + case C308 => 308 + case C309 => 309 + case C310 => 310 + case C311 => 311 + case C312 => 312 + case C313 => 313 + case C314 => 314 + case C315 => 315 + case C316 => 316 + case C317 => 317 + case C318 => 318 + case C319 => 319 + case C320 => 320 + case C321 => 321 + case C322 => 322 + case C323 => 323 + case C324 => 324 + case C325 => 325 + case C326 => 326 + case C327 => 327 + case C328 => 328 + case C329 => 329 + case C330 => 330 + case C331 => 331 + case C332 => 332 + case C333 => 333 + case C334 => 334 + case C335 => 335 + case C336 => 336 + case C337 => 337 + case C338 => 338 + case C339 => 339 + case C340 => 340 + case C341 => 341 + case C342 => 342 + case C343 => 343 + case C344 => 344 + case C345 => 345 + case C346 => 346 + case C347 => 347 + case C348 => 348 + case C349 => 349 + case C350 => 350 + case C351 => 351 + case C352 => 352 + case C353 => 353 + case C354 => 354 + case C355 => 355 + case C356 => 356 + case C357 => 357 + case C358 => 358 + case C359 => 359 + case C360 => 360 + case C361 => 361 + case C362 => 362 + case C363 => 363 + case C364 => 364 + case C365 => 365 + case C366 => 366 + case C367 => 367 + case C368 => 368 + case C369 => 369 + case C370 => 370 + case C371 => 371 + case C372 => 372 + case C373 => 373 + case C374 => 374 + case C375 => 375 + case C376 => 376 + case C377 => 377 + case C378 => 378 + case C379 => 379 + case C380 => 380 + case C381 => 381 + case C382 => 382 + case C383 => 383 + case C384 => 384 + case C385 => 385 + case C386 => 386 + case C387 => 387 + case C388 => 388 + case C389 => 389 + case C390 => 390 + case C391 => 391 + case C392 => 392 + case C393 => 393 + case C394 => 394 + case C395 => 395 + case C396 => 396 + case C397 => 397 + case C398 => 398 + case C399 => 399 + case C400 => 400 + } +} diff --git a/test/files/pos/t9239/Declaration.scala b/test/files/pos/t9239/Declaration.scala new file mode 100644 index 0000000000..452dcc1e77 --- /dev/null +++ b/test/files/pos/t9239/Declaration.scala @@ -0,0 +1,3 @@ +class Foo[A] +trait Bar[A] extends Foo[A] +class Baz[A] extends Bar[A] diff --git a/test/files/pos/t9239/Usage.java b/test/files/pos/t9239/Usage.java new file mode 100644 index 0000000000..d1e3fb0c3e --- /dev/null +++ b/test/files/pos/t9239/Usage.java @@ -0,0 +1,15 @@ +/** + * Used to fail with: + * + * Usage.java:5: error: incompatible types: Baz<String> cannot be converted to Foo<String> + * foo(f); + * ^ + */ +public class Usage { + public Usage() { + Baz<String> f = null; + foo(f); + } + + public void foo(Foo<String> f) { }; +} diff --git a/test/files/pos/t9285.flags b/test/files/pos/t9285.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/pos/t9285.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/pos/t9285.scala b/test/files/pos/t9285.scala new file mode 100644 index 0000000000..b7146cdf1c --- /dev/null +++ b/test/files/pos/t9285.scala @@ -0,0 +1 @@ +case class C(placeholder: Unit) diff --git a/test/files/pos/virtpatmat_exhaust_big.scala b/test/files/pos/virtpatmat_exhaust_big.scala new file mode 100644 index 0000000000..9850933540 --- /dev/null +++ b/test/files/pos/virtpatmat_exhaust_big.scala @@ -0,0 +1,33 @@ +sealed abstract class Z +object Z { + object Z0 extends Z + case class Z1() extends Z + object Z2 extends Z + case class Z3() extends Z + object Z4 extends Z + case class Z5() extends Z + object Z6 extends Z + case class Z7() extends Z + object Z8 extends Z + case class Z9() extends Z + object Z10 extends Z + case class Z11() extends Z + object Z12 extends Z + case class Z13() extends Z + object Z14 extends Z + case class Z15() extends Z + object Z16 extends Z + case class Z17() extends Z + object Z18 extends Z + case class Z19() extends Z +} + +// drop any case and it will report an error +object Test { + import Z._ + def foo(z: Z) = z match { + case Z0 | Z1() | Z2 | Z3() | Z4 | Z5() | Z6 | Z7() | Z8 | Z9() | + Z10 | Z11() | Z12 | Z13() | Z14 | Z15() | Z16 | Z17() | Z18 | Z19() + => + } +}
\ No newline at end of file diff --git a/test/files/presentation/doc.check b/test/files/presentation/doc.check new file mode 100644 index 0000000000..5a3ff13151 --- /dev/null +++ b/test/files/presentation/doc.check @@ -0,0 +1 @@ +reload: Base.scala, Class.scala, Derived.scala diff --git a/test/files/presentation/doc/doc.scala b/test/files/presentation/doc/doc.scala new file mode 100755 index 0000000000..f2233f1828 --- /dev/null +++ b/test/files/presentation/doc/doc.scala @@ -0,0 +1,147 @@ +import scala.reflect.internal.util.{ BatchSourceFile, SourceFile } +import scala.tools.nsc.doc +import scala.tools.nsc.doc.base._ +import scala.tools.nsc.doc.base.comment._ +import scala.tools.nsc.interactive._ +import scala.tools.nsc.interactive.tests._ + +object Test extends InteractiveTest { + val tags = Seq( + "@example `\"abb\".permutations = Iterator(abb, bab, bba)`", + "@version 1.0, 09/07/2012", + "@since 2.10", + "@todo this is unsafe!", + "@note Don't inherit!", + "@see something else" + ) + + val names = Seq("Class", "Def", "Val", "Var", "AbstracType", "TypeAlias", "Trait", "InnerClass") + val bareText = + """abstract class %s { + | def %s = "" + | val %s = "" + | var %s: String = _ + | type %s + | type %s = String + | class %s + |} + |trait %s""".stripMargin.format(names: _*) + + def docComment(nTags: Int) = "/**\n%s*/".format(tags.take(nTags).mkString("\n")) + + def text(name: String, nTags: Int) = { + val nameIndex = bareText.indexOf(name) + val (pre, post) = bareText.splitAt(nameIndex) + val crIndex = pre.lastIndexOf("\n") + val (prepre, prepost) = pre.splitAt(crIndex) + prepre + docComment(nTags) + prepost + post + } + + override lazy val compiler = { + prepareSettings(settings) + new Global(settings, compilerReporter) with MemberLookupBase with CommentFactoryBase with doc.ScaladocGlobalTrait { + outer => + + val global: this.type = this + + override lazy val analyzer = new { + val global: outer.type = outer + } with doc.ScaladocAnalyzer with InteractiveAnalyzer { + override def newTyper(context: Context): InteractiveTyper with ScaladocTyper = + new Typer(context) with InteractiveTyper with ScaladocTyper + } + + def chooseLink(links: List[LinkTo]): LinkTo = links.head + def internalLink(sym: Symbol, site: Symbol) = None + def toString(link: LinkTo) = link.toString + def warnNoLink = false + def findExternalLink(sym: Symbol, name: String) = None + + override def forScaladoc = true + + def getComment(sym: Symbol, source: SourceFile, fragments: List[(Symbol,SourceFile)]): Option[Comment] = { + val docResponse = new Response[(String, String, Position)] + askDocComment(sym, source, sym.owner, fragments, docResponse) + docResponse.get.left.toOption flatMap { + case (expanded, raw, pos) => + if (expanded.isEmpty) + None + else + Some(ask { () => parseAtSymbol(expanded, raw, pos, sym.owner) }) + } + } + } + } + + override def runDefaultTests() { + import compiler._ + def findSource(name: String) = sourceFiles.find(_.file.name == name).get + + val className = names.head + for (name <- names; + i <- 1 to tags.length) { + val newText = text(name, i) + val source = findSource("Class.scala") + val batch = new BatchSourceFile(source.file, newText.toCharArray) + val reloadResponse = new Response[Unit] + compiler.askReload(List(batch), reloadResponse) + reloadResponse.get.left.toOption match { + case None => + println("Couldn't reload") + case Some(_) => + val parseResponse = new Response[Tree] + askParsedEntered(batch, true, parseResponse) + parseResponse.get.left.toOption match { + case None => + println("Couldn't parse") + case Some(_) => + val sym = compiler.ask { () => + val toplevel = compiler.rootMirror.EmptyPackage.info.decl(TypeName(name)) + if (toplevel eq NoSymbol) { + val clazz = compiler.rootMirror.EmptyPackage.info.decl(TypeName(className)) + val term = clazz.info.decl(TermName(name)) + if (term eq NoSymbol) clazz.info.decl(TypeName(name)) else + if (term.isAccessor) term.accessed else term + } else toplevel + } + + getComment(sym, batch, (sym,batch)::Nil) match { + case None => println(s"Got no doc comment for $name") + case Some(comment) => + import comment._ + def cnt(bodies: Iterable[Body]) = bodies.size + val actual = cnt(example) + cnt(version) + cnt(since) + cnt(todo) + cnt(note) + cnt(see) + if (actual != i) + println(s"Got docComment with $actual tags instead of $i, file text:\n$newText") + } + } + } + } + + // Check inter-classes documentation one-time retrieved ok. + val baseSource = findSource("Base.scala") + val derivedSource = findSource("Derived.scala") + def existsText(where: Any, text: String): Boolean = where match { + case s: String => s contains text + case s: Seq[_] => s exists (existsText(_, text)) + case p: Product => p.productIterator exists (existsText(_, text)) + case c: Comment => existsText(c.body, text) + } + val (derived, base) = compiler.ask { () => + val derived = compiler.rootMirror.RootPackage.info.decl(newTermName("p")).info.decl(newTypeName("Derived")) + (derived, derived.ancestors(0)) + } + val cmt1 = getComment(derived, derivedSource, (base, baseSource)::(derived, derivedSource)::Nil) + if (!existsText(cmt1, "This is Derived comment")) + println("Unexpected Derived class comment:"+cmt1) + + val (fooDerived, fooBase) = compiler.ask { () => + val decl = derived.tpe.decl(newTermName("foo")) + (decl, decl.allOverriddenSymbols(0)) + } + + val cmt2 = getComment(fooDerived, derivedSource, (fooBase, baseSource)::(fooDerived, derivedSource)::Nil) + if (!existsText(cmt2, "Base method has documentation")) + println("Unexpected foo method comment:"+cmt2) + } +} diff --git a/test/files/presentation/doc/src/Class.scala b/test/files/presentation/doc/src/Class.scala new file mode 100755 index 0000000000..a974bd6f5c --- /dev/null +++ b/test/files/presentation/doc/src/Class.scala @@ -0,0 +1 @@ +object Class
\ No newline at end of file diff --git a/test/files/presentation/doc/src/p/Base.scala b/test/files/presentation/doc/src/p/Base.scala new file mode 100755 index 0000000000..d91632b6f6 --- /dev/null +++ b/test/files/presentation/doc/src/p/Base.scala @@ -0,0 +1,11 @@ +package p + +/** + * @define BaseComment This is $BaseVar comment. + */ +trait Base { + /** + * Base method has documentation. + */ + def foo: String +} diff --git a/test/files/presentation/doc/src/p/Derived.scala b/test/files/presentation/doc/src/p/Derived.scala new file mode 100755 index 0000000000..1a9c9a26d1 --- /dev/null +++ b/test/files/presentation/doc/src/p/Derived.scala @@ -0,0 +1,9 @@ +package p + +/** + * $BaseComment + * @define BaseVar Derived + */ +class Derived extends Base { + def foo = "" +} diff --git a/test/files/presentation/ide-bug-1000531.check b/test/files/presentation/ide-bug-1000531.check index d8c7a369f7..12eafcd6de 100644 --- a/test/files/presentation/ide-bug-1000531.check +++ b/test/files/presentation/ide-bug-1000531.check @@ -1,111 +1,24 @@ -reload: CrashOnLoad.scala +reload: CrashOnLoad.scala, TestIterable.java -askTypeCompletion at CrashOnLoad.scala(6,12) +askTypeCompletion at CrashOnLoad.scala(6,11) ================================================================================ -[response] askTypeCompletion at (6,12) -retrieved 117 members +[response] askTypeCompletion at (6,11) +retrieved 30 members [inaccessible] protected[package lang] def clone(): Object [inaccessible] protected[package lang] def finalize(): Unit -[inaccessible] protected[this] def reversed: List[B] -class GroupedIterator[B >: A] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]] def +(other: String): String -def ++[B >: B](that: => scala.collection.GenTraversableOnce[B]): Iterator[B] -def ->[B](y: B): (java.util.Iterator[B], B) -def /:[B](z: B)(op: (B, B) => B): B -def :\[B](z: B)(op: (B, B) => B): B -def addString(b: StringBuilder): StringBuilder -def addString(b: StringBuilder,sep: String): StringBuilder -def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder -def aggregate[B](z: => B)(seqop: (B, B) => B,combop: (B, B) => B): B -def buffered: scala.collection.BufferedIterator[B] -def collectFirst[B](pf: PartialFunction[B,B]): Option[B] -def collect[B](pf: PartialFunction[B,B]): Iterator[B] -def contains(elem: Any): Boolean -def copyToArray[B >: B](xs: Array[B]): Unit -def copyToArray[B >: B](xs: Array[B],start: Int): Unit -def copyToArray[B >: B](xs: Array[B],start: Int,len: Int): Unit -def copyToBuffer[B >: B](dest: scala.collection.mutable.Buffer[B]): Unit -def corresponds[B](that: scala.collection.GenTraversableOnce[B])(p: (B, B) => Boolean): Boolean -def count(p: B => Boolean): Int -def drop(n: Int): Iterator[B] -def dropWhile(p: B => Boolean): Iterator[B] -def duplicate: (Iterator[B], Iterator[B]) -def ensuring(cond: Boolean): java.util.Iterator[B] -def ensuring(cond: Boolean,msg: => Any): java.util.Iterator[B] -def ensuring(cond: java.util.Iterator[B] => Boolean): java.util.Iterator[B] -def ensuring(cond: java.util.Iterator[B] => Boolean,msg: => Any): java.util.Iterator[B] +def ->[B](y: B): (other.TestIterator[Nothing], B) +def ensuring(cond: Boolean): other.TestIterator[Nothing] +def ensuring(cond: Boolean,msg: => Any): other.TestIterator[Nothing] +def ensuring(cond: other.TestIterator[Nothing] => Boolean): other.TestIterator[Nothing] +def ensuring(cond: other.TestIterator[Nothing] => Boolean,msg: => Any): other.TestIterator[Nothing] def equals(x$1: Any): Boolean -def exists(p: B => Boolean): Boolean -def filter(p: B => Boolean): Iterator[B] -def filterNot(p: B => Boolean): Iterator[B] -def find(p: B => Boolean): Option[B] -def flatMap[B](f: B => scala.collection.GenTraversableOnce[B]): Iterator[B] -def foldLeft[B](z: B)(op: (B, B) => B): B -def foldRight[B](z: B)(op: (B, B) => B): B -def fold[A1 >: B](z: A1)(op: (A1, A1) => A1): A1 -def forall(p: B => Boolean): Boolean -def foreach[U](f: B => U): Unit def formatted(fmtstr: String): String -def grouped[B >: B](size: Int): Iterator[B]#GroupedIterator[B] -def hasDefiniteSize: Boolean -def hasNext(): Boolean +def hasNext: Boolean def hashCode(): Int -def indexOf[B >: B](elem: B): Int -def indexWhere(p: B => Boolean): Int -def isEmpty: Boolean -def isTraversableAgain: Boolean -def length: Int -def map[B](f: B => B): Iterator[B] -def maxBy[B](f: B => B)(implicit cmp: Ordering[B]): B -def max[B >: B](implicit cmp: Ordering[B]): B -def minBy[B](f: B => B)(implicit cmp: Ordering[B]): B -def min[B >: B](implicit cmp: Ordering[B]): B -def mkString(sep: String): String -def mkString(start: String,sep: String,end: String): String -def mkString: String -def next(): B -def nonEmpty: Boolean -def padTo[A1 >: B](len: Int,elem: A1): Iterator[A1] -def partition(p: B => Boolean): (Iterator[B], Iterator[B]) -def patch[B >: B](from: Int,patchElems: Iterator[B],replaced: Int): Iterator[B] -def product[B >: B](implicit num: Numeric[B]): B -def reduceLeftOption[B >: B](op: (B, B) => B): Option[B] -def reduceLeft[B >: B](op: (B, B) => B): B -def reduceOption[A1 >: B](op: (A1, A1) => A1): Option[A1] -def reduceRightOption[B >: B](op: (B, B) => B): Option[B] -def reduceRight[B >: B](op: (B, B) => B): B -def reduce[A1 >: B](op: (A1, A1) => A1): A1 -def remove(): Unit -def sameElements(that: Iterator[_]): Boolean -def scanLeft[B](z: B)(op: (B, B) => B): Iterator[B] -def scanRight[B](z: B)(op: (B, B) => B): Iterator[B] -def seq: Iterator[B] -def size: Int -def slice(from: Int,until: Int): Iterator[B] -def sliding[B >: B](size: Int,step: Int): Iterator[B]#GroupedIterator[B] -def span(p: B => Boolean): (Iterator[B], Iterator[B]) -def sum[B >: B](implicit num: Numeric[B]): B -def take(n: Int): Iterator[B] -def takeWhile(p: B => Boolean): Iterator[B] -def toArray[B >: B](implicit evidence$1: scala.reflect.ClassTag[B]): Array[B] -def toBuffer[B >: B]: scala.collection.mutable.Buffer[B] -def toIndexedSeq: scala.collection.immutable.IndexedSeq[B] -def toIterable: Iterable[B] -def toIterator: Iterator[B] -def toList: List[B] -def toMap[T, U](implicit ev: <:<[B,(T, U)]): scala.collection.immutable.Map[T,U] -def toSeq: Seq[B] -def toSet[B >: B]: scala.collection.immutable.Set[B] -def toStream: scala.collection.immutable.Stream[B] +def next: T def toString(): String -def toTraversable: Traversable[B] -def toVector: Vector[B] -def to[Col[_]](implicit cbf: scala.collection.generic.CanBuildFrom[Nothing,B,Col[B]]): Col[B] -def withFilter(p: B => Boolean): Iterator[B] -def zipAll[B, A1 >: B, B1 >: B](that: Iterator[B],thisElem: A1,thatElem: B1): Iterator[(A1, B1)] -def zipWithIndex: Iterator[(B, Int)] -def zip[B](that: Iterator[B]): Iterator[(B, B)] -def →[B](y: B): (java.util.Iterator[B], B) +def →[B](y: B): (other.TestIterator[Nothing], B) final def !=(x$1: Any): Boolean final def ##(): Int final def ==(x$1: Any): Boolean diff --git a/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala b/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala index 878bbfa19e..3f59282083 100644 --- a/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala +++ b/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala @@ -1,7 +1,14 @@ /** When this files is opened within the IDE, a typing error is reported. */ -class A[B] extends java.lang.Iterable[B] { +class A[B] extends TestIterable[B] { import scala.collection.JavaConversions._ - def iterator = Iterator.empty + def iterator: other.TestIterator[Nothing] = ??? - iterator. /*!*/ -}
\ No newline at end of file + iterator./*!*/ +} + +object other { + trait TestIterator[T] { + def hasNext: Boolean + def next: T + } +} diff --git a/test/files/presentation/ide-bug-1000531/src/TestIterable.java b/test/files/presentation/ide-bug-1000531/src/TestIterable.java new file mode 100644 index 0000000000..84a6fe77f1 --- /dev/null +++ b/test/files/presentation/ide-bug-1000531/src/TestIterable.java @@ -0,0 +1,7 @@ +public abstract class TestIterable<T> { + public abstract TestIterator<T> iterator(); + public static abstract class TestIterator<T> { + public abstract T next(); + public abstract boolean hasNext(); + } +} diff --git a/test/files/presentation/infix-completion.check b/test/files/presentation/infix-completion.check new file mode 100644 index 0000000000..f62dc81d34 --- /dev/null +++ b/test/files/presentation/infix-completion.check @@ -0,0 +1,193 @@ +reload: Snippet.scala + +askTypeCompletion at Snippet.scala(1,34) +================================================================================ +[response] askTypeCompletion at (1,34) +retrieved 192 members +[inaccessible] protected def integralNum: math.Numeric.DoubleAsIfIntegral.type +[inaccessible] protected def num: math.Numeric.DoubleIsFractional.type +[inaccessible] protected def ord: math.Ordering.Double.type +[inaccessible] protected def unifiedPrimitiveEquals(x: Any): Boolean +[inaccessible] protected def unifiedPrimitiveHashcode(): Int +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def !=(x: Byte): Boolean +def !=(x: Char): Boolean +def !=(x: Double): Boolean +def !=(x: Float): Boolean +def !=(x: Int): Boolean +def !=(x: Long): Boolean +def !=(x: Short): Boolean +def %(x: Byte): Int +def %(x: Char): Int +def %(x: Double): Double +def %(x: Float): Float +def %(x: Int): Int +def %(x: Long): Long +def %(x: Short): Int +def &(x: Byte): Int +def &(x: Char): Int +def &(x: Int): Int +def &(x: Long): Long +def &(x: Short): Int +def *(x: Byte): Int +def *(x: Char): Int +def *(x: Double): Double +def *(x: Float): Float +def *(x: Int): Int +def *(x: Long): Long +def *(x: Short): Int +def +(x: Byte): Int +def +(x: Char): Int +def +(x: Double): Double +def +(x: Float): Float +def +(x: Int): Int +def +(x: Long): Long +def +(x: Short): Int +def +(x: String): String +def -(x: Byte): Int +def -(x: Char): Int +def -(x: Double): Double +def -(x: Float): Float +def -(x: Int): Int +def -(x: Long): Long +def -(x: Short): Int +def ->[B](y: B): (Int, B) +def /(x: Byte): Int +def /(x: Char): Int +def /(x: Double): Double +def /(x: Float): Float +def /(x: Int): Int +def /(x: Long): Long +def /(x: Short): Int +def <(x: Byte): Boolean +def <(x: Char): Boolean +def <(x: Double): Boolean +def <(x: Float): Boolean +def <(x: Int): Boolean +def <(x: Long): Boolean +def <(x: Short): Boolean +def <<(x: Int): Int +def <<(x: Long): Int +def <=(x: Byte): Boolean +def <=(x: Char): Boolean +def <=(x: Double): Boolean +def <=(x: Float): Boolean +def <=(x: Int): Boolean +def <=(x: Long): Boolean +def <=(x: Short): Boolean +def ==(x: Byte): Boolean +def ==(x: Char): Boolean +def ==(x: Double): Boolean +def ==(x: Float): Boolean +def ==(x: Int): Boolean +def ==(x: Long): Boolean +def ==(x: Short): Boolean +def >(x: Byte): Boolean +def >(x: Char): Boolean +def >(x: Double): Boolean +def >(x: Float): Boolean +def >(x: Int): Boolean +def >(x: Long): Boolean +def >(x: Short): Boolean +def >=(x: Byte): Boolean +def >=(x: Char): Boolean +def >=(x: Double): Boolean +def >=(x: Float): Boolean +def >=(x: Int): Boolean +def >=(x: Long): Boolean +def >=(x: Short): Boolean +def >>(x: Int): Int +def >>(x: Long): Int +def >>>(x: Int): Int +def >>>(x: Long): Int +def ^(x: Byte): Int +def ^(x: Char): Int +def ^(x: Int): Int +def ^(x: Long): Long +def ^(x: Short): Int +def byteValue(): Byte +def ceil: Double +def compare(y: Double): Int +def compare(y: Long): Int +def compareTo(that: Double): Int +def compareTo(that: Long): Int +def compareTo(x$1: Double): Int +def compareTo(x$1: Long): Int +def doubleValue(): Double +def ensuring(cond: Boolean): Int +def ensuring(cond: Boolean,msg: => Any): Int +def ensuring(cond: Int => Boolean): Int +def ensuring(cond: Int => Boolean,msg: => Any): Int +def equals(x$1: Any): Boolean +def floatValue(): Float +def floor: Double +def formatted(fmtstr: String): String +def hashCode(): Int +def intValue(): Int +def isInfinite(): Boolean +def isInfinity: Boolean +def isNaN(): Boolean +def isNegInfinity: Boolean +def isPosInfinity: Boolean +def isValidLong: Boolean +def longValue(): Long +def round: Long +def shortValue(): Short +def to(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]] +def to(end: Double,step: Double): scala.collection.immutable.NumericRange.Inclusive[Double] +def to(end: Long): scala.collection.immutable.NumericRange.Inclusive[Long] +def to(end: Long,step: Long): scala.collection.immutable.NumericRange.Inclusive[Long] +def toBinaryString: String +def toByte: Byte +def toChar: Char +def toDegrees: Double +def toDouble: Double +def toFloat: Float +def toHexString: String +def toInt: Int +def toLong: Long +def toOctalString: String +def toRadians: Double +def toShort: Short +def toString(): String +def unary_+: Int +def unary_-: Int +def unary_~: Int +def underlying(): AnyRef +def until(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]] +def until(end: Double,step: Double): scala.collection.immutable.NumericRange.Exclusive[Double] +def until(end: Long): scala.collection.immutable.NumericRange.Exclusive[Long] +def until(end: Long,step: Long): scala.collection.immutable.NumericRange.Exclusive[Long] +def |(x: Byte): Int +def |(x: Char): Int +def |(x: Int): Int +def |(x: Long): Long +def |(x: Short): Int +def →[B](y: B): (Int, B) +final def !=(x$1: Any): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +override def abs: Double +override def isValidByte: Boolean +override def isValidChar: Boolean +override def isValidInt: Boolean +override def isValidShort: Boolean +override def isWhole(): Boolean +override def max(that: Double): Double +override def max(that: Long): Long +override def min(that: Double): Double +override def min(that: Long): Long +override def signum: Int +private[this] val self: Double +================================================================================ diff --git a/test/files/presentation/infix-completion/Runner.scala b/test/files/presentation/infix-completion/Runner.scala new file mode 100644 index 0000000000..1c03e3d5ba --- /dev/null +++ b/test/files/presentation/infix-completion/Runner.scala @@ -0,0 +1,3 @@ +import scala.tools.nsc.interactive.tests._ + +object Test extends InteractiveTest diff --git a/test/files/presentation/infix-completion/src/Snippet.scala b/test/files/presentation/infix-completion/src/Snippet.scala new file mode 100644 index 0000000000..7e03c486ba --- /dev/null +++ b/test/files/presentation/infix-completion/src/Snippet.scala @@ -0,0 +1 @@ +object Snippet{val x = 123; 1 + 1./*!*/} diff --git a/test/files/presentation/infix-completion2.check b/test/files/presentation/infix-completion2.check new file mode 100644 index 0000000000..5c69cd84cb --- /dev/null +++ b/test/files/presentation/infix-completion2.check @@ -0,0 +1,211 @@ +reload: Snippet.scala + +askTypeCompletion at Snippet.scala(1,34) +================================================================================ +[response] askTypeCompletion at (1,34) +retrieved 211 members +[inaccessible] protected def integralNum: math.Numeric.DoubleAsIfIntegral.type +[inaccessible] protected def num: math.Numeric.DoubleIsFractional.type +[inaccessible] protected def ord: math.Ordering.Double.type +[inaccessible] protected def unifiedPrimitiveEquals(x: Any): Boolean +[inaccessible] protected def unifiedPrimitiveHashcode(): Int +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def !=(x: Byte): Boolean +def !=(x: Char): Boolean +def !=(x: Double): Boolean +def !=(x: Float): Boolean +def !=(x: Int): Boolean +def !=(x: Long): Boolean +def !=(x: Short): Boolean +def %(x: Byte): Int +def %(x: Char): Int +def %(x: Double): Double +def %(x: Float): Float +def %(x: Int): Int +def %(x: Long): Long +def %(x: Short): Int +def &(x: Byte): Int +def &(x: Char): Int +def &(x: Int): Int +def &(x: Long): Long +def &(x: Short): Int +def *(x: Byte): Int +def *(x: Char): Int +def *(x: Double): Double +def *(x: Float): Float +def *(x: Int): Int +def *(x: Long): Long +def *(x: Short): Int +def +(x: Byte): Int +def +(x: Char): Int +def +(x: Double): Double +def +(x: Float): Float +def +(x: Int): Int +def +(x: Long): Long +def +(x: Short): Int +def +(x: String): String +def -(x: Byte): Int +def -(x: Char): Int +def -(x: Double): Double +def -(x: Float): Float +def -(x: Int): Int +def -(x: Long): Long +def -(x: Short): Int +def ->[B](y: B): (Int, B) +def /(x: Byte): Int +def /(x: Char): Int +def /(x: Double): Double +def /(x: Float): Float +def /(x: Int): Int +def /(x: Long): Long +def /(x: Short): Int +def <(x: Byte): Boolean +def <(x: Char): Boolean +def <(x: Double): Boolean +def <(x: Float): Boolean +def <(x: Int): Boolean +def <(x: Long): Boolean +def <(x: Short): Boolean +def <<(x: Int): Int +def <<(x: Long): Int +def <=(x: Byte): Boolean +def <=(x: Char): Boolean +def <=(x: Double): Boolean +def <=(x: Float): Boolean +def <=(x: Int): Boolean +def <=(x: Long): Boolean +def <=(x: Short): Boolean +def ==(x: Byte): Boolean +def ==(x: Char): Boolean +def ==(x: Double): Boolean +def ==(x: Float): Boolean +def ==(x: Int): Boolean +def ==(x: Long): Boolean +def ==(x: Short): Boolean +def >(x: Byte): Boolean +def >(x: Char): Boolean +def >(x: Double): Boolean +def >(x: Float): Boolean +def >(x: Int): Boolean +def >(x: Long): Boolean +def >(x: Short): Boolean +def >=(x: Byte): Boolean +def >=(x: Char): Boolean +def >=(x: Double): Boolean +def >=(x: Float): Boolean +def >=(x: Int): Boolean +def >=(x: Long): Boolean +def >=(x: Short): Boolean +def >>(x: Int): Int +def >>(x: Long): Int +def >>>(x: Int): Int +def >>>(x: Long): Int +def ^(x: Byte): Int +def ^(x: Char): Int +def ^(x: Int): Int +def ^(x: Long): Long +def ^(x: Short): Int +def byteValue(): Byte +def ceil: Double +def compare(y: Double): Int +def compare(y: Float): Int +def compare(y: Int): Int +def compare(y: Long): Int +def compareTo(that: Double): Int +def compareTo(that: Float): Int +def compareTo(that: Int): Int +def compareTo(that: Long): Int +def compareTo(x$1: Double): Int +def compareTo(x$1: Float): Int +def compareTo(x$1: Integer): Int +def compareTo(x$1: Long): Int +def doubleValue(): Double +def ensuring(cond: Boolean): Int +def ensuring(cond: Boolean,msg: => Any): Int +def ensuring(cond: Int => Boolean): Int +def ensuring(cond: Int => Boolean,msg: => Any): Int +def equals(x$1: Any): Boolean +def floatValue(): Float +def floor: Double +def formatted(fmtstr: String): String +def hashCode(): Int +def intValue(): Int +def isInfinite(): Boolean +def isInfinity: Boolean +def isNaN(): Boolean +def isNegInfinity: Boolean +def isPosInfinity: Boolean +def isValidLong: Boolean +def longValue(): Long +def round: Long +def shortValue(): Short +def to(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]] +def to(end: Double,step: Double): scala.collection.immutable.NumericRange.Inclusive[Double] +def to(end: Float): Range.Partial[Float,scala.collection.immutable.NumericRange[Float]] +def to(end: Float,step: Float): scala.collection.immutable.NumericRange.Inclusive[Float] +def to(end: Int): scala.collection.immutable.Range.Inclusive +def to(end: Int,step: Int): scala.collection.immutable.Range.Inclusive +def to(end: Long): scala.collection.immutable.NumericRange.Inclusive[Long] +def to(end: Long,step: Long): scala.collection.immutable.NumericRange.Inclusive[Long] +def toBinaryString: String +def toByte: Byte +def toChar: Char +def toDegrees: Double +def toDouble: Double +def toFloat: Float +def toHexString: String +def toInt: Int +def toLong: Long +def toOctalString: String +def toRadians: Double +def toShort: Short +def toString(): String +def unary_+: Int +def unary_-: Int +def unary_~: Int +def underlying(): AnyRef +def until(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]] +def until(end: Double,step: Double): scala.collection.immutable.NumericRange.Exclusive[Double] +def until(end: Float): Range.Partial[Float,scala.collection.immutable.NumericRange[Float]] +def until(end: Float,step: Float): scala.collection.immutable.NumericRange.Exclusive[Float] +def until(end: Int): scala.collection.immutable.Range +def until(end: Int,step: Int): scala.collection.immutable.Range +def until(end: Long): scala.collection.immutable.NumericRange.Exclusive[Long] +def until(end: Long,step: Long): scala.collection.immutable.NumericRange.Exclusive[Long] +def |(x: Byte): Int +def |(x: Char): Int +def |(x: Int): Int +def |(x: Long): Long +def |(x: Short): Int +def →[B](y: B): (Int, B) +final def !=(x$1: Any): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +override def abs: Double +override def isValidByte: Boolean +override def isValidChar: Boolean +override def isValidInt: Boolean +override def isValidShort: Boolean +override def isWhole(): Boolean +override def max(that: Double): Double +override def max(that: Float): Float +override def max(that: Int): Int +override def max(that: Long): Long +override def min(that: Double): Double +override def min(that: Float): Float +override def min(that: Int): Int +override def min(that: Long): Long +override def signum: Int +private[this] val self: Double +================================================================================ diff --git a/test/files/presentation/infix-completion2/Runner.scala b/test/files/presentation/infix-completion2/Runner.scala new file mode 100644 index 0000000000..1c03e3d5ba --- /dev/null +++ b/test/files/presentation/infix-completion2/Runner.scala @@ -0,0 +1,3 @@ +import scala.tools.nsc.interactive.tests._ + +object Test extends InteractiveTest diff --git a/test/files/presentation/infix-completion2/src/Snippet.scala b/test/files/presentation/infix-completion2/src/Snippet.scala new file mode 100644 index 0000000000..4eb8c24a2e --- /dev/null +++ b/test/files/presentation/infix-completion2/src/Snippet.scala @@ -0,0 +1 @@ +object Snippet{val x = 123; 1 + x./*!*/} diff --git a/test/files/presentation/private-case-class-members.check b/test/files/presentation/private-case-class-members.check new file mode 100644 index 0000000000..678f9a34e6 --- /dev/null +++ b/test/files/presentation/private-case-class-members.check @@ -0,0 +1 @@ +Test OK diff --git a/test/files/presentation/private-case-class-members/Test.scala b/test/files/presentation/private-case-class-members/Test.scala new file mode 100644 index 0000000000..e64c8238ea --- /dev/null +++ b/test/files/presentation/private-case-class-members/Test.scala @@ -0,0 +1,34 @@ +import scala.tools.nsc.interactive.tests.InteractiveTest +import scala.reflect.internal.util.SourceFile +import scala.tools.nsc.interactive.Response + +object Test extends InteractiveTest { + override def execute(): Unit = { + val source = loadSourceAndWaitUntilTypechecked("State.scala") + checkErrors(source) + } + + private def loadSourceAndWaitUntilTypechecked(sourceName: String): SourceFile = { + val sourceFile = sourceFiles.find(_.file.name == sourceName).head + compiler.askToDoFirst(sourceFile) + val res = new Response[Unit] + compiler.askReload(List(sourceFile), res) + res.get + askLoadedTyped(sourceFile).get + // the second round of type-checking makes it fail + compiler.askReload(List(sourceFile), res) + res.get + askLoadedTyped(sourceFile).get + + sourceFile + } + + private def checkErrors(source: SourceFile): Unit = compiler.getUnitOf(source) match { + case Some(unit) => + val problems = unit.problems.toList + if(problems.isEmpty) reporter.println("Test OK") + else problems.foreach(problem => reporter.println(problem.msg)) + + case None => reporter.println("No compilation unit found for " + source.file.name) + } +} diff --git a/test/files/presentation/private-case-class-members/src/State.scala b/test/files/presentation/private-case-class-members/src/State.scala new file mode 100644 index 0000000000..c31817076c --- /dev/null +++ b/test/files/presentation/private-case-class-members/src/State.scala @@ -0,0 +1,5 @@ +object State +case class State(private val foo: Int) + +case class State2(private val foo: Int) +object State2 diff --git a/test/files/presentation/quasiquotes.flags b/test/files/presentation/quasiquotes.flags new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/presentation/quasiquotes.flags diff --git a/test/files/presentation/t7915.check b/test/files/presentation/t7915.check index b18b4ddb55..0849aaa82b 100644 --- a/test/files/presentation/t7915.check +++ b/test/files/presentation/t7915.check @@ -9,3 +9,23 @@ askHyperlinkPos for `bar` at (7,22) Foo.scala ================================================================================ [response] found askHyperlinkPos for `bar` at (2,7) Foo.scala ================================================================================ + +askHyperlinkPos for `Bar` at (8,11) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `Bar` at (1,7) Foo.scala +================================================================================ + +askHyperlinkPos for `baz` at (8,22) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `baz` at (2,31) Foo.scala +================================================================================ + +askHyperlinkPos for `Bar` at (9,11) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `Bar` at (1,7) Foo.scala +================================================================================ + +askHyperlinkPos for `baz` at (9,22) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `baz` at (2,31) Foo.scala +================================================================================ diff --git a/test/files/presentation/t7915/src/Foo.scala b/test/files/presentation/t7915/src/Foo.scala index a4166ae5b4..5c9ca36a6e 100644 --- a/test/files/presentation/t7915/src/Foo.scala +++ b/test/files/presentation/t7915/src/Foo.scala @@ -1,9 +1,11 @@ class Bar { - def bar(b: Int = 2) {} + def bar(b: Int = 2) {}; def baz[X](b: Int = 2) {} } class Foo { def foo() { new Bar/*#*/().bar/*#*/() + new Bar/*#*/().baz/*#*/[Any]() + new Bar/*#*/().baz/*#*/() } } diff --git a/test/files/presentation/t8459.check b/test/files/presentation/t8459.check new file mode 100644 index 0000000000..336c147141 --- /dev/null +++ b/test/files/presentation/t8459.check @@ -0,0 +1,14 @@ +reload: IncompleteDynamicSelect.scala + +askType at IncompleteDynamicSelect.scala(12,2) +================================================================================ +[response] askTypeAt (12,2) +scala.AnyRef { + def <init>(): Foo = { + Foo.super.<init>(); + () + }; + private[this] val bar: F = new F(); + Foo.this.bar.<selectDynamic: error>("<error>") +} +================================================================================ diff --git a/test/files/presentation/t8459/Test.scala b/test/files/presentation/t8459/Test.scala new file mode 100644 index 0000000000..bec1131c4c --- /dev/null +++ b/test/files/presentation/t8459/Test.scala @@ -0,0 +1,3 @@ +import scala.tools.nsc.interactive.tests.InteractiveTest + +object Test extends InteractiveTest
\ No newline at end of file diff --git a/test/files/presentation/t8459/src/IncompleteDynamicSelect.scala b/test/files/presentation/t8459/src/IncompleteDynamicSelect.scala new file mode 100644 index 0000000000..61976fe2f9 --- /dev/null +++ b/test/files/presentation/t8459/src/IncompleteDynamicSelect.scala @@ -0,0 +1,14 @@ +import scala.language.dynamics + +class F extends Dynamic { + def applyDynamic(name: String)(args: Any*) = + s"method '$name' called with arguments ${args.mkString("'", "', '", "'")}" +} + +class Foo { + val bar = new F + + bar. //note whitespace after dot + /*?*/ //force typechecking +} + diff --git a/test/files/presentation/t8934.check b/test/files/presentation/t8934.check new file mode 100644 index 0000000000..0ece87f808 --- /dev/null +++ b/test/files/presentation/t8934.check @@ -0,0 +1,2 @@ +reload: Source.scala +Test OK diff --git a/test/files/presentation/t8934/Runner.scala b/test/files/presentation/t8934/Runner.scala new file mode 100644 index 0000000000..944f458391 --- /dev/null +++ b/test/files/presentation/t8934/Runner.scala @@ -0,0 +1,27 @@ +import scala.tools.nsc.interactive.tests.InteractiveTest +import scala.reflect.internal.util.SourceFile +import scala.tools.nsc.interactive.Response + +object Test extends InteractiveTest { + + override def execute(): Unit = { + val src = loadSourceAndWaitUntilTypechecked("Source.scala") + checkErrors(src) + } + + private def loadSourceAndWaitUntilTypechecked(sourceName: String): SourceFile = { + val sourceFile = sourceFiles.find(_.file.name == sourceName).head + askReload(List(sourceFile)).get + askLoadedTyped(sourceFile).get + sourceFile + } + + private def checkErrors(source: SourceFile): Unit = compiler.getUnitOf(source) match { + case Some(unit) => + val problems = unit.problems.toList + if(problems.isEmpty) reporter.println("Test OK") + else problems.foreach(problem => reporter.println(problem.msg)) + + case None => reporter.println("No compilation unit found for " + source.file.name) + } +} diff --git a/test/files/presentation/t8934/src/Source.scala b/test/files/presentation/t8934/src/Source.scala new file mode 100644 index 0000000000..769c8fd38b --- /dev/null +++ b/test/files/presentation/t8934/src/Source.scala @@ -0,0 +1,10 @@ +class Quasi { + import reflect.runtime.universe._ + + def test: Unit = { + (null: Any) match { + case q"$foo($bar)" => + } + () + } +} diff --git a/test/files/presentation/t8941.check b/test/files/presentation/t8941.check new file mode 100644 index 0000000000..341804903a --- /dev/null +++ b/test/files/presentation/t8941.check @@ -0,0 +1,7 @@ +reload: Source.scala + +askType at Source.scala(6,7) +================================================================================ +[response] askTypeAt (6,7) +scala.this.Predef.??? +================================================================================ diff --git a/test/files/presentation/t8941/Runner.scala b/test/files/presentation/t8941/Runner.scala new file mode 100644 index 0000000000..0a8923a583 --- /dev/null +++ b/test/files/presentation/t8941/Runner.scala @@ -0,0 +1,11 @@ +import scala.tools.nsc.interactive.tests.InteractiveTest + +object Test extends InteractiveTest { + override def runDefaultTests() { + // make sure typer is done.. the virtual pattern matcher might translate + // some trees and mess up positions. But we'll catch it red handed! + // sourceFiles foreach (src => askLoadedTyped(src).get) + super.runDefaultTests() + } + +} diff --git a/test/files/presentation/t8941/src/Source.scala b/test/files/presentation/t8941/src/Source.scala new file mode 100644 index 0000000000..7438cccb03 --- /dev/null +++ b/test/files/presentation/t8941/src/Source.scala @@ -0,0 +1,8 @@ +object Foo { + implicit class MatCreator(val ctx: StringContext) extends AnyVal { + def m(args: Any*): Unit = { + ctx.checkLengths(args) + } + ???/*?*/ + } +} diff --git a/test/files/presentation/t8941b/IdempotencyTest.scala b/test/files/presentation/t8941b/IdempotencyTest.scala new file mode 100644 index 0000000000..af01b36898 --- /dev/null +++ b/test/files/presentation/t8941b/IdempotencyTest.scala @@ -0,0 +1,73 @@ +package scala.tools.nsc +package interactive +package tests.core + +import reporters.{Reporter => CompilerReporter} +import scala.tools.nsc.interactive.InteractiveReporter +import scala.reflect.internal.util.SourceFile + +/** Determistically interrupts typechecking of `code` when a defintion named + * `MagicInterruptionMarker` is typechecked, and then performs a targetted + * typecheck of the tree at the specal comment marker marker + */ +abstract class IdempotencyTest { self => + private val settings = new Settings + settings.usejavacp.value = true + + private object Break extends scala.util.control.ControlThrowable + + private val compilerReporter: CompilerReporter = new InteractiveReporter { + override def compiler = self.compiler + } + + object compiler extends Global(settings, compilerReporter) { + override def checkForMoreWork(pos: Position) { + } + override def signalDone(context: Context, old: Tree, result: Tree) { + // println("signalDone: " + old.toString.take(50).replaceAll("\n", "\\n")) + if (!interrupted && analyzer.lockedCount == 0 && interruptsEnabled && shouldInterrupt(result)) { + interrupted = true + val typed = typedTreeAt(markerPosition) + checkTypedTree(typed) + throw Break + } + super.signalDone(context, old, result) + } + + // we're driving manually using our own thread, disable the check here. + override def assertCorrectThread() {} + } + + import compiler._ + + private var interrupted = false + + // Extension points + protected def code: String + protected def shouldInterrupt(tree: Tree): Boolean = { + tree.symbol != null && tree.symbol.name.toString == "MagicInterruptionMarker" + } + protected def checkTypedTree(tree: Tree): Unit = {} + + + private val source: SourceFile = newSourceFile(code) + private def markerPosition: Position = source.position(code.indexOf("/*?*/")) + + def assertNoProblems() { + val problems = getUnit(source).get.problems + assert(problems.isEmpty, problems.mkString("\n")) + } + + def show() { + reloadSource(source) + try { + typedTree(source, true) + assert(false, "Expected to break out of typechecking.") + } catch { + case Break => // expected + } + assertNoProblems() + } + + def main(args: Array[String]) { show() } +} diff --git a/test/files/presentation/t8941b/Test.scala b/test/files/presentation/t8941b/Test.scala new file mode 100644 index 0000000000..7269a14286 --- /dev/null +++ b/test/files/presentation/t8941b/Test.scala @@ -0,0 +1,53 @@ +import scala.tools.nsc.interactive.tests.core.IdempotencyTest + +// At the time of writing this test, removing any part of `enterExistingSym` +// leads to a failure. +object Test { + def main(args: Array[String]) { + test(""" + object Foo { + def term { + def foo(c: String = "") = c + class MagicInterruptionMarker + foo()/*?*/ + } + } + """) + + test(""" + object Foo { + def term { + def foo = 42 + class MagicInterruptionMarker + foo/*?*/ + } + } + """) + + test(""" + object Foo { + def term { + lazy val foo = 42 + class MagicInterruptionMarker + foo/*?*/ + } + } + """) + + test(""" + object Foo { + implicit class C(val a: String) extends AnyVal + class MagicInterruptionMarker + ""/*?*/ + } + """) + } + + def test(code0: String) { + val t = new IdempotencyTest { + def code = code0 + } + t.show() + } +} + diff --git a/test/files/presentation/visibility/src/Completions.scala b/test/files/presentation/visibility/src/Completions.scala index 8c07934915..69ec3959ad 100644 --- a/test/files/presentation/visibility/src/Completions.scala +++ b/test/files/presentation/visibility/src/Completions.scala @@ -11,7 +11,7 @@ package accessibility { def secretPublic(): Unit def someTests(other: Foo) { - other./*!*/secretPrivate // should be all but scretThis + other./*!*/secretPrivate // should be all but secretThis this./*!*/secretProtected // should hit five completions } @@ -25,7 +25,7 @@ package accessibility { class UnrelatedClass { def someTests(foo: Foo) { - foo./*!*/ // should list public and protected[accessiblity] + foo./*!*/ // should list public and protected[accessibility] } } diff --git a/test/files/res/t6613.check b/test/files/res/t6613.check new file mode 100644 index 0000000000..bbd9331b16 --- /dev/null +++ b/test/files/res/t6613.check @@ -0,0 +1,5 @@ + +nsc> +nsc> +nsc> +nsc> diff --git a/test/files/res/t6613.res b/test/files/res/t6613.res new file mode 100644 index 0000000000..e3fa000fdd --- /dev/null +++ b/test/files/res/t6613.res @@ -0,0 +1,3 @@ +t6613/Enummy.java +t6613/Broken.scala +t6613/Broken.scala diff --git a/test/files/res/t6613/Broken.scala b/test/files/res/t6613/Broken.scala new file mode 100644 index 0000000000..9bcd12dbe1 --- /dev/null +++ b/test/files/res/t6613/Broken.scala @@ -0,0 +1 @@ +class Broken() { def broken() = Enummy.Broke.CHIP } diff --git a/test/files/res/t6613/Enummy.java b/test/files/res/t6613/Enummy.java new file mode 100644 index 0000000000..1863ef1297 --- /dev/null +++ b/test/files/res/t6613/Enummy.java @@ -0,0 +1 @@ +public class Enummy { public enum Broke { SHARD, CHIP } } diff --git a/test/files/res/t8871.check b/test/files/res/t8871.check new file mode 100644 index 0000000000..bbd9331b16 --- /dev/null +++ b/test/files/res/t8871.check @@ -0,0 +1,5 @@ + +nsc> +nsc> +nsc> +nsc> diff --git a/test/files/res/t8871.res b/test/files/res/t8871.res new file mode 100644 index 0000000000..9b1a5fb57f --- /dev/null +++ b/test/files/res/t8871.res @@ -0,0 +1,4 @@ +t8871/tag.scala +t8871/usetag.scala +t8871/usetag.scala + diff --git a/test/files/res/t8871/tag.scala b/test/files/res/t8871/tag.scala new file mode 100644 index 0000000000..1a1803b77d --- /dev/null +++ b/test/files/res/t8871/tag.scala @@ -0,0 +1,3 @@ +class Tag { + @inline def apply[@specialized A, T](a: A): A = a +} diff --git a/test/files/res/t8871/usetag.scala b/test/files/res/t8871/usetag.scala new file mode 100644 index 0000000000..139d768552 --- /dev/null +++ b/test/files/res/t8871/usetag.scala @@ -0,0 +1,6 @@ +trait Foo + +object Test { + val y = new Tag().apply[Double, Foo](3.3) + // under FSC, this gave t8871/usetag.scala:4: error: wrong number of type parameters for method apply$mDc$sp: [T](a: Double)Double +} diff --git a/test/files/res/t9089.check b/test/files/res/t9089.check new file mode 100644 index 0000000000..6cf64f734b --- /dev/null +++ b/test/files/res/t9089.check @@ -0,0 +1,4 @@ + +nsc> +nsc> +nsc> diff --git a/test/files/res/t9089.res b/test/files/res/t9089.res new file mode 100644 index 0000000000..ab5cc8534d --- /dev/null +++ b/test/files/res/t9089.res @@ -0,0 +1,2 @@ +t9089/A.scala +t9089/A.scala diff --git a/test/files/res/t9089/A.scala b/test/files/res/t9089/A.scala new file mode 100644 index 0000000000..bccf269639 --- /dev/null +++ b/test/files/res/t9089/A.scala @@ -0,0 +1 @@ +object O { def f(x: => Int): Int = x } diff --git a/test/files/res/t9170.check b/test/files/res/t9170.check new file mode 100644 index 0000000000..6d40b6ba8d --- /dev/null +++ b/test/files/res/t9170.check @@ -0,0 +1,7 @@ + +nsc> t9170/A.scala:3: error: double definition: +def f[A](a: => A): Int at line 2 and +def f[A](a: => Either[Exception,A]): Int at line 3 +have same type after erasure: (a: Function0)Int + def f[A](a: => Either[Exception, A]) = 2 + ^ diff --git a/test/files/res/t9170.res b/test/files/res/t9170.res new file mode 100644 index 0000000000..c2aec2f8dd --- /dev/null +++ b/test/files/res/t9170.res @@ -0,0 +1,2 @@ +t9170/A.scala +t9170/A.scala diff --git a/test/files/res/t9170/A.scala b/test/files/res/t9170/A.scala new file mode 100644 index 0000000000..239df89679 --- /dev/null +++ b/test/files/res/t9170/A.scala @@ -0,0 +1,4 @@ +object Y { + def f[A](a: => A) = 1 + def f[A](a: => Either[Exception, A]) = 2 +} diff --git a/test/files/run/abstypetags_serialize.check b/test/files/run/abstypetags_serialize.check index bddc4523e6..1b5e2ebddf 100644 --- a/test/files/run/abstypetags_serialize.check +++ b/test/files/run/abstypetags_serialize.check @@ -1,2 +1,2 @@ -java.io.NotSerializableException: Test$$typecreator1$1 -java.io.NotSerializableException: Test$$typecreator2$1 +WeakTypeTag[T] +WeakTypeTag[U[String]] diff --git a/test/files/run/analyzerPlugins.check b/test/files/run/analyzerPlugins.check index e3ab554d4c..9803465ddc 100644 --- a/test/files/run/analyzerPlugins.check +++ b/test/files/run/analyzerPlugins.check @@ -19,7 +19,7 @@ canAdaptAnnotations(Trees$Typed, Any) [1] canAdaptAnnotations(Trees$Typed, Int) [1] lub(List(Int @testAnn, Int)) [1] pluginsPt(?, Trees$Annotated) [7] -pluginsPt(?, Trees$Apply) [9] +pluginsPt(?, Trees$Apply) [8] pluginsPt(?, Trees$ApplyImplicitView) [2] pluginsPt(?, Trees$Assign) [7] pluginsPt(?, Trees$Block) [4] @@ -31,13 +31,13 @@ pluginsPt(?, Trees$Literal) [16] pluginsPt(?, Trees$New) [5] pluginsPt(?, Trees$PackageDef) [1] pluginsPt(?, Trees$Return) [1] -pluginsPt(?, Trees$Select) [48] +pluginsPt(?, Trees$Select) [47] pluginsPt(?, Trees$Super) [2] pluginsPt(?, Trees$This) [20] -pluginsPt(?, Trees$TypeApply) [4] +pluginsPt(?, Trees$TypeApply) [3] pluginsPt(?, Trees$TypeBoundsTree) [2] pluginsPt(?, Trees$TypeDef) [1] -pluginsPt(?, Trees$TypeTree) [39] +pluginsPt(?, Trees$TypeTree) [38] pluginsPt(?, Trees$Typed) [1] pluginsPt(?, Trees$ValDef) [21] pluginsPt(Any, Trees$Literal) [2] @@ -98,7 +98,6 @@ pluginsTyped(()String, Trees$Ident) [1] pluginsTyped(()String, Trees$TypeApply) [1] pluginsTyped(()scala.annotation.Annotation, Trees$Select) [1] pluginsTyped(()testAnn, Trees$Select) [10] -pluginsTyped(()type, Trees$TypeApply) [1] pluginsTyped((str: String)A <and> (param: Double)A, Trees$Select) [1] pluginsTyped((x$1: Any)Boolean <and> (x: Double)Boolean <and> (x: Float)Boolean <and> (x: Long)Boolean <and> (x: Int)Boolean <and> (x: Char)Boolean <and> (x: Short)Boolean <and> (x: Byte)Boolean, Trees$Select) [1] pluginsTyped((x$1: Int)Unit, Trees$Select) [1] @@ -173,7 +172,7 @@ pluginsTyped(Unit, Trees$Literal) [5] pluginsTyped(Unit, Trees$TypeTree) [1] pluginsTyped([A](xs: A*)List[A], Trees$Select) [1] pluginsTyped([T <: Int]=> Int, Trees$Select) [1] -pluginsTyped([T0]()T0, Trees$Select) [2] +pluginsTyped([T0]()T0, Trees$Select) [1] pluginsTyped([T](xs: Array[T])scala.collection.mutable.WrappedArray[T], Trees$Select) [1] pluginsTyped(annotation.type, Trees$Select) [4] pluginsTyped(math.type, Trees$Select) [9] @@ -190,7 +189,5 @@ pluginsTyped(testAnn, Trees$New) [5] pluginsTyped(testAnn, Trees$This) [1] pluginsTyped(testAnn, Trees$TypeTree) [2] pluginsTyped(testAnn.super.type, Trees$Super) [1] -pluginsTyped(type, Trees$Apply) [1] pluginsTyped(type, Trees$Select) [1] -pluginsTyped(type, Trees$TypeTree) [1] pluginsTypedReturn(return f, String) [1] diff --git a/test/files/run/applydynamic_sip.flags b/test/files/run/applydynamic_sip.flags index 1141f97507..ba6d37305e 100644 --- a/test/files/run/applydynamic_sip.flags +++ b/test/files/run/applydynamic_sip.flags @@ -1 +1,2 @@ +-Yrangepos:false -language:dynamics diff --git a/test/files/run/applydynamic_sip.scala b/test/files/run/applydynamic_sip.scala index cf918a82ed..47d0c6a303 100644 --- a/test/files/run/applydynamic_sip.scala +++ b/test/files/run/applydynamic_sip.scala @@ -40,7 +40,7 @@ object Test extends App { // qual.sel(arg = a, a2: _*) // qual.sel(arg, arg2 = "a2", a2: _*) - // If qual.sel appears immediately on the left-hand side of an assigment + // If qual.sel appears immediately on the left-hand side of an assignment // qual.updateDynamic(“sel”)(expr) qual.sel = expr diff --git a/test/files/run/bcodeInlinerMixed.flags b/test/files/run/bcodeInlinerMixed.flags new file mode 100644 index 0000000000..63b5558cfd --- /dev/null +++ b/test/files/run/bcodeInlinerMixed.flags @@ -0,0 +1 @@ +-Ybackend:GenBCode -Yopt:l:classpath
\ No newline at end of file diff --git a/test/files/run/bcodeInlinerMixed/A_1.java b/test/files/run/bcodeInlinerMixed/A_1.java new file mode 100644 index 0000000000..44d7d88eeb --- /dev/null +++ b/test/files/run/bcodeInlinerMixed/A_1.java @@ -0,0 +1,3 @@ +public class A_1 { + public static final int bar() { return 100; } +} diff --git a/test/files/run/bcodeInlinerMixed/B_1.scala b/test/files/run/bcodeInlinerMixed/B_1.scala new file mode 100644 index 0000000000..2aadeccb82 --- /dev/null +++ b/test/files/run/bcodeInlinerMixed/B_1.scala @@ -0,0 +1,20 @@ +// Partest does proper mixed compilation: +// 1. scalac *.scala *.java +// 2. javac *.java +// 3. scalc *.scala +// +// In the second scalc round, the classfile for A_1 is on the classpath. +// Therefore the inliner has access to the bytecode of `bar`, which means +// it can verify that the invocation to `bar` can be safely inlined. +// +// So both callsites of `flop` are inlined. +// +// In a single mixed compilation, `flop` cannot be inlined, see JUnit InlinerTest.scala, def mixedCompilationNoInline. + +class B { + @inline final def flop = A_1.bar + def g = flop +} +class C { + def h(b: B) = b.flop +} diff --git a/test/files/run/bcodeInlinerMixed/Test.scala b/test/files/run/bcodeInlinerMixed/Test.scala new file mode 100644 index 0000000000..c8c7a9fe2a --- /dev/null +++ b/test/files/run/bcodeInlinerMixed/Test.scala @@ -0,0 +1,16 @@ +import scala.tools.partest.{BytecodeTest, ASMConverters} +import ASMConverters._ + +object Test extends BytecodeTest { + def show: Unit = { + val gIns = instructionsFromMethod(getMethod(loadClassNode("B"), "g")) + val hIns = instructionsFromMethod(getMethod(loadClassNode("C"), "h")) + // val invocation = Invoke(INVOKESTATIC, A_1, bar, ()I, false) + for (i <- List(gIns, hIns)) { + assert(i exists { + case Invoke(_, _, "bar", "()I", _) => true + case _ => false + }, i mkString "\n") + } + } +} diff --git a/test/files/run/bitsets.check b/test/files/run/bitsets.check index 41c2ccdcb8..c24fd6238f 100644 --- a/test/files/run/bitsets.check +++ b/test/files/run/bitsets.check @@ -1,3 +1,4 @@ +warning: there were three deprecation warnings; re-run with -deprecation for details ms0 = BitSet(2) ms1 = BitSet(2) ms2 = BitSet(2) diff --git a/test/files/run/class-symbol-contravariant.check b/test/files/run/class-symbol-contravariant.check index 987f215bca..cbb90b52c2 100644 --- a/test/files/run/class-symbol-contravariant.check +++ b/test/files/run/class-symbol-contravariant.check @@ -33,4 +33,4 @@ res2: Boolean = true scala> sym.isContravariant // was true res3: Boolean = false -scala> +scala> :quit diff --git a/test/files/run/classfile-format-51.scala b/test/files/run/classfile-format-51.scala index f92382d89b..7523130afa 100644 --- a/test/files/run/classfile-format-51.scala +++ b/test/files/run/classfile-format-51.scala @@ -12,7 +12,7 @@ import Opcodes._ // it runs a normal compile on the source in the 'code' field that refers to // DynamicInvoker. Any failure will be dumped to std out. // -// By it's nature the test can only work on JDK 7+ because under JDK 6 some of the +// By its nature the test can only work on JDK 7+ because under JDK 6 some of the // classes referred to by DynamicInvoker won't be available and DynamicInvoker won't // verify. So the test includes a version check that short-circuites the whole test // on JDK 6 @@ -32,7 +32,7 @@ object Test extends DirectTest { val constructor = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null) constructor.visitCode() constructor.visitVarInsn(ALOAD, 0) - constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V") + constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false) constructor.visitInsn(RETURN) constructor.visitMaxs(1, 1) constructor.visitEnd() @@ -47,19 +47,19 @@ object Test extends DirectTest { val bootstrap = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, bootstrapMethodName, bootStrapMethodType, null, null) bootstrap.visitCode() // val lookup = MethodHandles.lookup(); - bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodHandles", "lookup", "()Ljava/lang/invoke/MethodHandles$Lookup;") + bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodHandles", "lookup", "()Ljava/lang/invoke/MethodHandles$Lookup;", false) bootstrap.visitVarInsn(ASTORE, 3) // lookup // val clazz = lookup.lookupClass(); bootstrap.visitVarInsn(ALOAD, 3) // lookup - bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "lookupClass", "()Ljava/lang/Class;") + bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "lookupClass", "()Ljava/lang/Class;", false) bootstrap.visitVarInsn(ASTORE, 4) // clazz // val methodType = MethodType.fromMethodDescriptorString("()Ljava/lang/String, clazz.getClassLoader()") bootstrap.visitLdcInsn("()Ljava/lang/String;") bootstrap.visitVarInsn(ALOAD, 4) // CLAZZ - bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getClassLoader", "()Ljava/lang/ClassLoader;") - bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodType", "fromMethodDescriptorString", "(Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/invoke/MethodType;") + bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getClassLoader", "()Ljava/lang/ClassLoader;", false) + bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodType", "fromMethodDescriptorString", "(Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/invoke/MethodType;", false) bootstrap.visitVarInsn(ASTORE, 5) // methodType // val methodHandle = lookup.findStatic(thisClass, "target", methodType) @@ -67,14 +67,14 @@ object Test extends DirectTest { bootstrap.visitVarInsn(ALOAD, 4) // clazz bootstrap.visitLdcInsn("target") bootstrap.visitVarInsn(ALOAD, 5) // methodType - bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "findStatic", "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;") + bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "findStatic", "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;", false) bootstrap.visitVarInsn(ASTORE, 6) // methodHandle // new ConstantCallSite(methodHandle) bootstrap.visitTypeInsn(NEW, "java/lang/invoke/ConstantCallSite") bootstrap.visitInsn(DUP) bootstrap.visitVarInsn(ALOAD, 6) // methodHandle - bootstrap.visitMethodInsn(INVOKESPECIAL, "java/lang/invoke/ConstantCallSite", "<init>", "(Ljava/lang/invoke/MethodHandle;)V") + bootstrap.visitMethodInsn(INVOKESPECIAL, "java/lang/invoke/ConstantCallSite", "<init>", "(Ljava/lang/invoke/MethodHandle;)V", false) bootstrap.visitInsn(ARETURN) bootstrap.visitMaxs(4,7) bootstrap.visitEnd() diff --git a/test/files/run/classfile-format-52.scala b/test/files/run/classfile-format-52.scala index e12c84124c..453f61ac84 100644 --- a/test/files/run/classfile-format-52.scala +++ b/test/files/run/classfile-format-52.scala @@ -11,7 +11,7 @@ import Opcodes._ // HasDefaultMethod. Then it runs a normal compile on Scala source that extends that // interface. Any failure will be dumped to std out. // -// By it's nature the test can only work on JDK 8+ because under JDK 7- the +// By its nature the test can only work on JDK 8+ because under JDK 7- the // interface won't verify. object Test extends DirectTest { override def extraSettings: String = "-optimise -usejavacp -d " + testOutput.path + " -cp " + testOutput.path diff --git a/test/files/run/collection-stacks.check b/test/files/run/collection-stacks.check index 895bde374d..3a366bfcdf 100644 --- a/test/files/run/collection-stacks.check +++ b/test/files/run/collection-stacks.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details 3-2-1: true 3-2-1: true apply diff --git a/test/files/run/colltest.check b/test/files/run/colltest.check index 1e850bb582..9579d781aa 100644 --- a/test/files/run/colltest.check +++ b/test/files/run/colltest.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details true false true diff --git a/test/files/run/colltest1.scala b/test/files/run/colltest1.scala index 8dce69afc9..de8780a050 100644 --- a/test/files/run/colltest1.scala +++ b/test/files/run/colltest1.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with */ import scala.collection._ import scala.language.postfixOps diff --git a/test/files/run/compiler-asSeenFrom.scala b/test/files/run/compiler-asSeenFrom.scala index ea96c6fba7..a60c2e8925 100644 --- a/test/files/run/compiler-asSeenFrom.scala +++ b/test/files/run/compiler-asSeenFrom.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warning; re-run with */ import scala.tools.nsc._ import scala.tools.partest.DirectTest diff --git a/test/files/run/constant-type.check b/test/files/run/constant-type.check index 77bdf618e6..a7ba5a46c2 100644 --- a/test/files/run/constant-type.check +++ b/test/files/run/constant-type.check @@ -23,4 +23,4 @@ Class[String](classOf[java.lang.String]) scala> { ConstantType(Constant(s)); exitingPhase(currentRun.erasurePhase)(println(ConstantType(Constant(s)))); } Class(classOf[java.lang.String]) -scala> +scala> :quit diff --git a/test/files/run/constrained-types.check b/test/files/run/constrained-types.check index 9a106785a1..89a08d5ccb 100644 --- a/test/files/run/constrained-types.check +++ b/test/files/run/constrained-types.check @@ -71,11 +71,11 @@ scala> var four = "four" four: String = four scala> val four2 = m(four) // should have an existential bound -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details four2: String @Annot(x) forSome { val x: String } = four scala> val four3 = four2 // should have the same type as four2 -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details four3: String @Annot(x) forSome { val x: String } = four scala> val stuff = m("stuff") // should not crash @@ -98,7 +98,7 @@ scala> def m = { val y : String @Annot(x) = x y } // x should not escape the local scope with a narrow type -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details m: String @Annot(x) forSome { val x: String } scala> @@ -112,7 +112,7 @@ scala> def n(y: String) = { } m("stuff".stripMargin) } // x should be existentially bound -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details n: (y: String)String @Annot(x) forSome { val x: String } scala> @@ -148,4 +148,4 @@ scala> val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message ^ -scala> +scala> :quit diff --git a/test/files/run/delambdafy-specialized.check b/test/files/run/delambdafy-specialized.check new file mode 100644 index 0000000000..c6903b9e29 --- /dev/null +++ b/test/files/run/delambdafy-specialized.check @@ -0,0 +1 @@ +scala.runtime.AbstractFunction1$mcII$sp diff --git a/test/files/run/delambdafy-specialized.flags b/test/files/run/delambdafy-specialized.flags new file mode 100644 index 0000000000..48b438ddf8 --- /dev/null +++ b/test/files/run/delambdafy-specialized.flags @@ -0,0 +1 @@ +-Ydelambdafy:method diff --git a/test/files/run/delambdafy-specialized.scala b/test/files/run/delambdafy-specialized.scala new file mode 100644 index 0000000000..634d4e490b --- /dev/null +++ b/test/files/run/delambdafy-specialized.scala @@ -0,0 +1,6 @@ +object Test { + def main(args: Array[String]): Unit = { + val f = (x: Int) => -x + println(f.getClass.getSuperclass.getName) + } +} diff --git a/test/files/run/delambdafyLambdaClassNames.check b/test/files/run/delambdafyLambdaClassNames.check new file mode 100644 index 0000000000..d425d15dd0 --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames.check @@ -0,0 +1 @@ +A$$nestedInAnon$1$lambda$$run$1 diff --git a/test/files/run/delambdafyLambdaClassNames.flags b/test/files/run/delambdafyLambdaClassNames.flags new file mode 100644 index 0000000000..b10233d322 --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames.flags @@ -0,0 +1 @@ +-Ybackend:GenBCode -Ydelambdafy:method
\ No newline at end of file diff --git a/test/files/run/delambdafyLambdaClassNames/A_1.scala b/test/files/run/delambdafyLambdaClassNames/A_1.scala new file mode 100644 index 0000000000..10489414b7 --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames/A_1.scala @@ -0,0 +1,5 @@ +class A { + def f = new Runnable { + def run(): Unit = List(1,2).foreach(println) + } +} diff --git a/test/files/run/delambdafyLambdaClassNames/Test.scala b/test/files/run/delambdafyLambdaClassNames/Test.scala new file mode 100644 index 0000000000..49a397d1d2 --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames/Test.scala @@ -0,0 +1,4 @@ +object Test extends App { + val c = Class.forName("A$$nestedInAnon$1$lambda$$run$1") + println(c.getName) +} diff --git a/test/files/run/delambdafy_t6028.check b/test/files/run/delambdafy_t6028.check index 92cfbaefb6..419e7043a3 100644 --- a/test/files/run/delambdafy_t6028.check +++ b/test/files/run/delambdafy_t6028.check @@ -1,35 +1,35 @@ [[syntax trees at end of lambdalift]] // newSource1.scala package <empty> { class T extends Object { - <paramaccessor> private[this] val classParam: Int = _; - def <init>(classParam: Int): T = { + <paramaccessor> private[this] val classParam: String = _; + def <init>(classParam: String): T = { T.super.<init>(); () }; - private[this] val field: Int = 0; - <stable> <accessor> def field(): Int = T.this.field; - def foo(methodParam: Int): Function0 = { - val methodLocal: Int = 0; + private[this] val field: String = ""; + <stable> <accessor> def field(): String = T.this.field; + def foo(methodParam: String): Function0 = { + val methodLocal: String = ""; { (() => T.this.$anonfun$1(methodParam, methodLocal)).$asInstanceOf[Function0]() } }; - def bar(barParam: Int): Object = { + def bar(barParam: String): Object = { @volatile var MethodLocalObject$module: runtime.VolatileObjectRef = scala.runtime.VolatileObjectRef.zero(); T.this.MethodLocalObject$1(barParam, MethodLocalObject$module) }; - def tryy(tryyParam: Int): Function0 = { - var tryyLocal: runtime.IntRef = scala.runtime.IntRef.create(0); + def tryy(tryyParam: String): Function0 = { + var tryyLocal: runtime.ObjectRef = scala.runtime.ObjectRef.create(""); { - (() => T.this.$anonfun$2(tryyParam, tryyLocal)).$asInstanceOf[Function0]() + (new <$anon: Function0>(T.this, tryyParam, tryyLocal): Function0) } }; - final <artifact> private[this] def $anonfun$1(methodParam$1: Int, methodLocal$1: Int): Int = T.this.classParam.+(T.this.field()).+(methodParam$1).+(methodLocal$1); + final <artifact> private[this] def $anonfun$1(methodParam$1: String, methodLocal$1: String): String = T.this.classParam.+(T.this.field()).+(methodParam$1).+(methodLocal$1); abstract trait MethodLocalTrait$1 extends Object { <synthetic> <stable> <artifact> def $outer(): T }; object MethodLocalObject$2 extends Object with T#MethodLocalTrait$1 { - def <init>($outer: T, barParam$1: Int): T#MethodLocalObject$2.type = { + def <init>($outer: T, barParam$1: String): T#MethodLocalObject$2.type = { MethodLocalObject$2.super.<init>(); MethodLocalObject$2.this.$asInstanceOf[T#MethodLocalTrait$1$class]()./*MethodLocalTrait$1$class*/$init$(barParam$1); () @@ -38,20 +38,35 @@ package <empty> { <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer; <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer }; - final <stable> private[this] def MethodLocalObject$1(barParam$1: Int, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = { + final <stable> private[this] def MethodLocalObject$1(barParam$1: String, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = { MethodLocalObject$module$1.elem = new T#MethodLocalObject$2.type(T.this, barParam$1); MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]() }; abstract trait MethodLocalTrait$1$class extends Object with T#MethodLocalTrait$1 { - def /*MethodLocalTrait$1$class*/$init$(barParam$1: Int): Unit = { + def /*MethodLocalTrait$1$class*/$init$(barParam$1: String): Unit = { () }; - scala.this.Predef.print(scala.Int.box(barParam$1)) + scala.this.Predef.print(barParam$1) }; - final <artifact> private[this] def $anonfun$2(tryyParam$1: Int, tryyLocal$1: runtime.IntRef): Unit = try { - tryyLocal$1.elem = tryyParam$1 - } finally () + @SerialVersionUID(value = 0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable { + def <init>($outer: T, tryyParam$1: String, tryyLocal$1: runtime.ObjectRef): <$anon: Function0> = { + $anonfun$tryy$1.super.<init>(); + () + }; + final def apply(): Unit = $anonfun$tryy$1.this.apply$mcV$sp(); + <specialized> def apply$mcV$sp(): Unit = try { + $anonfun$tryy$1.this.tryyLocal$1.elem = $anonfun$tryy$1.this.tryyParam$1 + } finally (); + <synthetic> <paramaccessor> <artifact> private[this] val $outer: T = _; + <synthetic> <stable> <artifact> def $outer(): T = $anonfun$tryy$1.this.$outer; + final <bridge> <artifact> def apply(): Object = { + $anonfun$tryy$1.this.apply(); + scala.runtime.BoxedUnit.UNIT + }; + <synthetic> <paramaccessor> private[this] val tryyParam$1: String = _; + <synthetic> <paramaccessor> private[this] val tryyLocal$1: runtime.ObjectRef = _ + } } } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details diff --git a/test/files/run/delambdafy_t6028.scala b/test/files/run/delambdafy_t6028.scala index 0b7ef48c3d..ca39195310 100644 --- a/test/files/run/delambdafy_t6028.scala +++ b/test/files/run/delambdafy_t6028.scala @@ -5,11 +5,11 @@ object Test extends DirectTest { override def extraSettings: String = "-usejavacp -Ydelambdafy:method -Xprint:lambdalift -d " + testOutput.path - override def code = """class T(classParam: Int) { - | val field: Int = 0 - | def foo(methodParam: Int) = {val methodLocal = 0 ; () => classParam + field + methodParam + methodLocal } - | def bar(barParam: Int) = { trait MethodLocalTrait { print(barParam) }; object MethodLocalObject extends MethodLocalTrait; MethodLocalObject } - | def tryy(tryyParam: Int) = { var tryyLocal = 0; () => try { tryyLocal = tryyParam } finally () } + override def code = """class T(classParam: String) { + | val field: String = "" + | def foo(methodParam: String) = {val methodLocal = "" ; () => classParam + field + methodParam + methodLocal } + | def bar(barParam: String) = { trait MethodLocalTrait { print(barParam) }; object MethodLocalObject extends MethodLocalTrait; MethodLocalObject } + | def tryy(tryyParam: String) = { var tryyLocal = ""; () => try { tryyLocal = tryyParam } finally () } |} |""".stripMargin.trim diff --git a/test/files/run/delambdafy_t6555.check b/test/files/run/delambdafy_t6555.check index 6b174c0d2a..b6ccebde78 100644 --- a/test/files/run/delambdafy_t6555.check +++ b/test/files/run/delambdafy_t6555.check @@ -5,11 +5,11 @@ package <empty> { Foo.super.<init>(); () }; - private[this] val f: Int => Int = { - final <artifact> def $anonfun(param: Int): Int = param; - ((param: Int) => $anonfun(param)) + private[this] val f: String => String = { + final <artifact> def $anonfun(param: String): String = param; + ((param: String) => $anonfun(param)) }; - <stable> <accessor> def f(): Int => Int = Foo.this.f + <stable> <accessor> def f(): String => String = Foo.this.f } } diff --git a/test/files/run/delambdafy_t6555.scala b/test/files/run/delambdafy_t6555.scala index a1dcfe790c..8d4976e989 100644 --- a/test/files/run/delambdafy_t6555.scala +++ b/test/files/run/delambdafy_t6555.scala @@ -5,7 +5,7 @@ object Test extends DirectTest { override def extraSettings: String = "-usejavacp -Xprint:specialize -Ydelambdafy:method -d " + testOutput.path - override def code = "class Foo { val f = (param: Int) => param } " + override def code = "class Foo { val f = (param: String) => param } " override def show(): Unit = { Console.withErr(System.out) { diff --git a/test/files/run/delambdafy_uncurry_byname_inline.check b/test/files/run/delambdafy_uncurry_byname_inline.check index 0dc69b379a..d96a995f44 100644 --- a/test/files/run/delambdafy_uncurry_byname_inline.check +++ b/test/files/run/delambdafy_uncurry_byname_inline.check @@ -7,7 +7,7 @@ package <empty> { }; def bar(x: () => Int): Int = x.apply(); def foo(): Int = Foo.this.bar({ - @SerialVersionUID(0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction0[Int] with Serializable { + @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction0[Int] with Serializable { def <init>(): <$anon: () => Int> = { $anonfun.super.<init>(); () diff --git a/test/files/run/delambdafy_uncurry_byname_method.check b/test/files/run/delambdafy_uncurry_byname_method.check index cd3edc7d6f..e0f281b1cd 100644 --- a/test/files/run/delambdafy_uncurry_byname_method.check +++ b/test/files/run/delambdafy_uncurry_byname_method.check @@ -5,9 +5,9 @@ package <empty> { Foo.super.<init>(); () }; - def bar(x: () => Int): Int = x.apply(); - def foo(): Int = Foo.this.bar({ - final <artifact> def $anonfun(): Int = 1; + def bar(x: () => String): String = x.apply(); + def foo(): String = Foo.this.bar({ + final <artifact> def $anonfun(): String = ""; (() => $anonfun()) }) } diff --git a/test/files/run/delambdafy_uncurry_byname_method.scala b/test/files/run/delambdafy_uncurry_byname_method.scala index 1adeec8433..0ccc1f2e92 100644 --- a/test/files/run/delambdafy_uncurry_byname_method.scala +++ b/test/files/run/delambdafy_uncurry_byname_method.scala @@ -6,9 +6,9 @@ object Test extends DirectTest { override def extraSettings: String = "-usejavacp -Xprint:uncurry -Ydelambdafy:method -Ystop-after:uncurry -d " + testOutput.path override def code = """class Foo { - | def bar(x: => Int) = x + | def bar(x: => String) = x | - | def foo = bar(1) + | def foo = bar("") |} |""".stripMargin.trim diff --git a/test/files/run/delambdafy_uncurry_inline.check b/test/files/run/delambdafy_uncurry_inline.check index e2b024b462..5521cc4a2c 100644 --- a/test/files/run/delambdafy_uncurry_inline.check +++ b/test/files/run/delambdafy_uncurry_inline.check @@ -7,7 +7,7 @@ package <empty> { }; def bar(): Unit = { val f: Int => Int = { - @SerialVersionUID(0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1[Int,Int] with Serializable { + @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1[Int,Int] with Serializable { def <init>(): <$anon: Int => Int> = { $anonfun.super.<init>(); () diff --git a/test/files/run/delay-bad.check b/test/files/run/delay-bad.check index 5d8c5fa1d4..cb6e329f7a 100644 --- a/test/files/run/delay-bad.check +++ b/test/files/run/delay-bad.check @@ -4,7 +4,7 @@ delay-bad.scala:53: warning: a pure expression does nothing in statement positio delay-bad.scala:73: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses f(new { val x = 5 } with E() { 5 }) ^ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details // new C { } diff --git a/test/files/run/eta-expand-star2.check b/test/files/run/eta-expand-star2.check index cbf4781255..d6929e4969 100644 --- a/test/files/run/eta-expand-star2.check +++ b/test/files/run/eta-expand-star2.check @@ -1,2 +1,2 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details hello diff --git a/test/files/run/existentials-in-compiler.scala b/test/files/run/existentials-in-compiler.scala index d019d56b42..e516eddf95 100644 --- a/test/files/run/existentials-in-compiler.scala +++ b/test/files/run/existentials-in-compiler.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with */ import scala.tools.nsc._ import scala.tools.partest.CompilerTest diff --git a/test/files/run/exprs_serialize.check b/test/files/run/exprs_serialize.check index 20ad6c110c..551823ccdc 100644 --- a/test/files/run/exprs_serialize.check +++ b/test/files/run/exprs_serialize.check @@ -1,2 +1,19 @@ -java.io.NotSerializableException: Test$$treecreator1$1 -java.io.NotSerializableException: Test$$treecreator2$1 +Expr[Int(2)](2) +Expr[java.lang.String]({ + def foo = "hello"; + foo.$plus("world!") +}) +Expr[Boolean]({ + def foo(x: Int) = { + class Local extends AnyRef { + def <init>() = { + super.<init>(); + () + }; + val f = 2 + }; + val obj = new Local(); + x.$percent(obj.f).$eq$eq(0) + }; + foo(5) +}) diff --git a/test/files/run/exprs_serialize.scala b/test/files/run/exprs_serialize.scala index c4310b0fe1..91027803b4 100644 --- a/test/files/run/exprs_serialize.scala +++ b/test/files/run/exprs_serialize.scala @@ -26,4 +26,14 @@ object Test extends App { test(reify(2)) test(reify{def foo = "hello"; foo + "world!"}) -}
\ No newline at end of file + test(reify { + def foo(x: Int) = { + class Local { + val f = 2 + } + val obj = new Local + x % obj.f == 0 + } + foo(5) + }) +} diff --git a/test/files/run/global-showdef.check b/test/files/run/global-showdef.check index 4c2fd41a1a..4ac96b4315 100644 --- a/test/files/run/global-showdef.check +++ b/test/files/run/global-showdef.check @@ -1,14 +1,14 @@ <<-- class foo.bar.Bippy after phase 'typer' -->> def showdefTestMemberClass1: Int +<<-- object foo.bar.Bippy after phase 'typer' -->> + def showdefTestMemberObject2: String <<-- type foo.bar.Bippy.BippyType after phase 'typer' -->> def showdefTestMemberType1: Unit +<<-- object foo.bar.Bippy.Boppity.Boo after phase 'typer' -->> + def showdefTestMemberObject1: String <<-- type foo.bar.Bippy.BippyType after phase 'typer' -->> def showdefTestMemberType2: Unit <<-- class foo.bar.Bippy.Boppity after phase 'typer' -->> def showdefTestMemberClass2: Int <<-- class foo.bar.Bippy.Boppity.Boo after phase 'typer' -->> def showdefTestMemberClass3: Int -<<-- object foo.bar.Bippy after phase 'typer' -->> - def showdefTestMemberObject2: String -<<-- object foo.bar.Bippy.Boppity.Boo after phase 'typer' -->> - def showdefTestMemberObject1: String diff --git a/test/files/run/global-showdef.scala b/test/files/run/global-showdef.scala index 1d4891fd1f..276fcc1e7c 100644 --- a/test/files/run/global-showdef.scala +++ b/test/files/run/global-showdef.scala @@ -1,11 +1,10 @@ -import scala.tools.nsc._ -import scala.reflect.io.AbstractFile +import scala.tools.partest.DirectTest import scala.tools.nsc.util.stringFromStream -import scala.reflect.internal.util.{ SourceFile, BatchSourceFile } -import scala.tools.nsc.reporters.ConsoleReporter -object Test { - val src: SourceFile = new BatchSourceFile("src", """ +object Test extends DirectTest { + override def extraSettings: String = "-usejavacp -Yshow:typer -Ystop-after:typer" + + override def code = """ package foo.bar class Bippy { @@ -32,39 +31,28 @@ object Bippy { def showdefTestMemberObject2 = "abc" } - """) + """ + + override def show(): Unit = { + val classes = List("Bippy", "Bippy#BippyType", "Bippy.BippyType", "Bippy#Boppity", "Bippy#Boppity#Boo") + val objects = List("Bippy", "Bippy#Boppity#Boo") + + def interesting(line: String) = (line contains "def showdefTestMember") || (line startsWith "<<-- ") - def mkCompiler(args: String*) = { - val settings = new Settings() - val command = new CompilerCommand("-usejavacp" :: args.toList, settings) + def run(args: String*) = slurp(args: _*).lines filter interesting foreach println - new Global(settings) + classes.zipAll(objects, "", "") foreach { + case (c, "") => run("-Xshow-class", c) + case (c, o) => run("-Xshow-class", c, "-Xshow-object", o) + } } - def slurp(body: => Unit): String = stringFromStream { stream => + // slurp the compilation result + def slurp(args: String*): String = stringFromStream { stream => Console.withOut(stream) { Console.withErr(stream) { - body + compile(args: _*) } } } - def lines(args: String*): List[String] = { - val output = slurp { - val compiler = mkCompiler(args: _*) - val run = new compiler.Run() - run.compileSources(List(src)) - } - output.lines.toList - } - def showClass(name: String) = lines("-Yshow:typer", "-Xshow-class", name) - def showObject(name: String) = lines("-Yshow:typer", "-Xshow-object", name) - - def show(xs: List[String]) = { - xs filter (x => (x contains "def showdefTestMember") || (x startsWith "<<-- ")) foreach println - } - - def main(args: Array[String]) { - show(List("Bippy", "Bippy#BippyType", "Bippy.BippyType", "Bippy#Boppity", "Bippy#Boppity#Boo") flatMap showClass) - show(List("Bippy", "Bippy#Boppity#Boo") flatMap showObject) - } } diff --git a/test/files/run/icode-reader-dead-code.check b/test/files/run/icode-reader-dead-code.check new file mode 100644 index 0000000000..c9de93283e --- /dev/null +++ b/test/files/run/icode-reader-dead-code.check @@ -0,0 +1,27 @@ +Bytecode for method f + + // access flags 0x11 + public final f()I + L0 + LINENUMBER 4 L0 + ICONST_1 + IRETURN + L1 + LOCALVARIABLE this Lp/A; L0 L1 0 + MAXSTACK = 1 + MAXLOCALS = 1 + +Bytecode for method f + + // access flags 0x11 + public final f()I + L0 + LINENUMBER 4 L0 + ICONST_1 + ATHROW + IRETURN + L1 + LOCALVARIABLE this Lp/A; L0 L1 0 + MAXSTACK = 1 + MAXLOCALS = 1 + diff --git a/test/files/run/icode-reader-dead-code.scala b/test/files/run/icode-reader-dead-code.scala new file mode 100644 index 0000000000..00ba58829f --- /dev/null +++ b/test/files/run/icode-reader-dead-code.scala @@ -0,0 +1,82 @@ +import java.io.{FileOutputStream, FileInputStream} + +import scala.tools.asm.{ClassWriter, Opcodes, ClassReader} +import scala.tools.asm.tree.{InsnNode, ClassNode} +import scala.tools.nsc.backend.jvm.AsmUtils +import scala.tools.partest.DirectTest +import scala.collection.JavaConverters._ + +/** + * Test that the ICodeReader does not crash if the bytecode of a method has unreachable code. + */ +object Test extends DirectTest { + def code: String = ??? + + def show(): Unit = { + // The bytecode of f will be modified using ASM by `addDeadCode` + val aCode = + """ + |package p + |class A { + | @inline final def f = 1 + |} + """.stripMargin + + val bCode = + """ + |package p + |class B { + | def g = (new A()).f + |} + """.stripMargin + + compileString(newCompiler("-usejavacp"))(aCode) + + addDeadCode() + + // If inlining fails, the compiler will issue an inliner warning that is not present in the + // check file + compileString(newCompiler("-usejavacp", "-optimise"))(bCode) + } + + def readClass(file: String) = { + val cnode = new ClassNode() + val is = new FileInputStream(file) + val reader = new ClassReader(is) + reader.accept(cnode, 0) + is.close() + cnode + } + + def writeClass(file: String, cnode: ClassNode): Unit = { + val writer = new ClassWriter(0) + cnode.accept(writer) + + val os = new FileOutputStream(file) + os.write(writer.toByteArray) + os.close() + } + + def addDeadCode() { + val file = (testOutput / "p" / "A.class").path + val cnode = readClass(file) + val method = cnode.methods.asScala.find(_.name == "f").head + + AsmUtils.traceMethod(method) + + val insns = method.instructions + val it = insns.iterator() + while (it.hasNext) { + val in = it.next() + if (in.getOpcode == Opcodes.IRETURN) { + // Insert an ATHROW before the IRETURN. The IRETURN will then be dead code. + // The ICodeReader should not crash if there's dead code. + insns.insert(in.getPrevious, new InsnNode(Opcodes.ATHROW)) + } + } + + AsmUtils.traceMethod(method) + + writeClass(file, cnode) + } +} diff --git a/test/files/run/inferred-type-constructors.check b/test/files/run/inferred-type-constructors.check index 5992ef02ad..4a63853bd9 100644 --- a/test/files/run/inferred-type-constructors.check +++ b/test/files/run/inferred-type-constructors.check @@ -1,4 +1,4 @@ -warning: there were 2 feature warning(s); re-run with -feature for details +warning: there were two feature warnings; re-run with -feature for details p.Iterable[Int] p.Set[Int] p.Seq[Int] diff --git a/test/files/run/interop_typetags_are_manifests.flags b/test/files/run/interop_typetags_are_manifests.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/run/interop_typetags_are_manifests.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/is-valid-num.scala b/test/files/run/is-valid-num.scala index 65e8ceeca6..156121cab5 100644 --- a/test/files/run/is-valid-num.scala +++ b/test/files/run/is-valid-num.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with */ object Test { def x = BigInt("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/test/files/run/iterator-concat.check b/test/files/run/iterator-concat.check deleted file mode 100644 index 23835b07ae..0000000000 --- a/test/files/run/iterator-concat.check +++ /dev/null @@ -1,4 +0,0 @@ -100 -1000 -10000 -100000 diff --git a/test/files/run/iterator-concat.scala b/test/files/run/iterator-concat.scala deleted file mode 100644 index f11363410f..0000000000 --- a/test/files/run/iterator-concat.scala +++ /dev/null @@ -1,15 +0,0 @@ -object Test { - // Create `size` Function0s, each of which evaluates to an Iterator - // which produces 1. Then fold them over ++ to get a single iterator, - // which should sum to "size". - def mk(size: Int): Iterator[Int] = { - val closures = (1 to size).toList.map(x => (() => Iterator(1))) - closures.foldLeft(Iterator.empty: Iterator[Int])((res, f) => res ++ f()) - } - def main(args: Array[String]): Unit = { - println(mk(100).sum) - println(mk(1000).sum) - println(mk(10000).sum) - println(mk(100000).sum) - } -} diff --git a/test/files/run/iterator-from.scala b/test/files/run/iterator-from.scala index 269e859657..e7ba1aeb28 100644 --- a/test/files/run/iterator-from.scala +++ b/test/files/run/iterator-from.scala @@ -1,5 +1,5 @@ /* This file tests iteratorFrom, keysIteratorFrom, and valueIteratorFrom on various sorted sets and maps - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with */ import scala.util.{Random => R} diff --git a/test/files/run/iterator-iterate-lazy.scala b/test/files/run/iterator-iterate-lazy.scala deleted file mode 100644 index 92b170062e..0000000000 --- a/test/files/run/iterator-iterate-lazy.scala +++ /dev/null @@ -1,5 +0,0 @@ -object Test { - def main(args: Array[String]): Unit = { - Iterator.iterate((1 to 5).toList)(_.tail).takeWhile(_.nonEmpty).map(_.head).toList - } -} diff --git a/test/files/run/iterators.check b/test/files/run/iterators.check deleted file mode 100644 index bb139c1610..0000000000 --- a/test/files/run/iterators.check +++ /dev/null @@ -1,13 +0,0 @@ -test check_from was successful -test check_range was successful -test check_range2 was successful -test check_range3 was successful -test check_take was successful -test check_drop was successful -test check_foreach was successful -test check_forall was successful -test check_fromArray was successful -test check_toSeq was successful -test check_indexOf was successful -test check_findIndexOf was successful - diff --git a/test/files/run/iterators.scala b/test/files/run/iterators.scala deleted file mode 100644 index 57e05d3472..0000000000 --- a/test/files/run/iterators.scala +++ /dev/null @@ -1,136 +0,0 @@ -//############################################################################ -// Iterators -//############################################################################ - -//############################################################################ - -import scala.language.postfixOps - -object Test { - - def check_from: Int = { - val it1 = Iterator.from(-1) - val it2 = Iterator.from(0, -1) - it1.next + it2.next - } - - def check_range: Int = { - val xs1 = Iterator.range(0, 10, 2) toList; - val xs2 = Iterator.range(0, 10, -2) toList; - val xs3 = Iterator.range(10, 0, -2) toList; - val xs4 = Iterator.range(10, 0, 2) toList; - val xs5 = Iterator.range(0, 10, 11) toList; - xs1.length + xs2.length + xs3.length + xs4.length + xs5.length - } - - def check_range2: Int = { - val r1start = 0 - val r1end = 10 - val r1step = 1 - val r1 = Iterator.range(r1start, r1end, r1step) toList; - val r2 = Iterator.range(r1start, r1end, r1step + 1) toList; - val r3 = Iterator.range(r1end, r1start, -r1step) toList; - val r4 = Iterator.range(0, 10, 11) toList; - // 10 + 5 + 10 + 1 - r1.length + r2.length + r3.length + r4.length - } - - def check_range3: Int = { - def trues(xs: List[Boolean]) = xs.foldLeft(0)((a, b) => if (b) a+1 else a) - val r1 = Iterator.range(0, 10) - val xs1 = List(r1 contains 5, r1 contains 6) - val r2a = Iterator.range(0, 10, 2) - val r2b = Iterator.range(0, 10, 2) - val xs2 = List(r2a contains 5, r2b contains 6) - val r3 = Iterator.range(0, 10, 11) - val xs3 = List(r3 contains 5, r3 contains 6) - // 2 + 1 + 0 - trues(xs1) + trues(xs2) + trues(xs3) - } - - def check_take: Int = { - val it1 = Iterator.from(0) - val xs1 = it1 take 10 toList; - xs1.length - } - - def check_drop: Int = { - val it1 = Iterator.from(0) - val it2 = it1 map { 2 * _ } - val n1 = it1 drop 2 next - val n2 = it2 drop 2 next; - n1 + n2 - } - - def check_foreach: Int = { - val it1 = Iterator.from(0) take 20 - var n = 0 - it1 foreach { n += _ } - n - } - - def check_forall: Int = { - val it1 = Iterator.from(0) - val it2 = Iterator.from(1) - 0 - } - - def check_fromArray: Int = { // ticket #429 - val a = List(1, 2, 3, 4).toArray - var xs0 = a.iterator.toList; - var xs1 = a.slice(0, 1).iterator.toList; - var xs2 = a.slice(0, 2).iterator.toList; - var xs3 = a.slice(0, 3).iterator.toList; - var xs4 = a.slice(0, 4).iterator.toList; - xs0.length + xs1.length + xs2.length + xs3.length + xs4.length - } - - def check_toSeq: String = - List(1, 2, 3, 4, 5).iterator.toSeq.mkString("x") - - def check_indexOf: String = { - val i = List(1, 2, 3, 4, 5).indexOf(4) - val j = List(1, 2, 3, 4, 5).indexOf(16) - "" + i + "x" + j - } - - def check_findIndexOf: String = { - val i = List(1, 2, 3, 4, 5).indexWhere { x: Int => x >= 4 } - val j = List(1, 2, 3, 4, 5).indexWhere { x: Int => x >= 16 } - "" + i + "x" + j - } - - def check_success[A](name: String, closure: => A, expected: A) { - print("test " + name) - try { - val actual: A = closure - if (actual == expected) - print(" was successful") - else - print(" failed: expected "+ expected +", found "+ actual) - } - catch { - case exception: Throwable => - print(" raised exception " + exception) - } - println() - } - - def main(args: Array[String]) { - check_success("check_from", check_from, -1) - check_success("check_range", check_range, 11) - check_success("check_range2", check_range2, 26) - check_success("check_range3", check_range3, 3) - check_success("check_take", check_take, 10) - check_success("check_drop", check_drop, 12) - check_success("check_foreach", check_foreach, 190) - check_success("check_forall", check_forall, 0) - check_success("check_fromArray",check_fromArray, 14) - check_success("check_toSeq", check_toSeq, "1x2x3x4x5") - check_success("check_indexOf", check_indexOf, "3x-1") - check_success("check_findIndexOf", check_findIndexOf, "3x-1") - println() - } -} - -//############################################################################ diff --git a/test/files/run/kind-repl-command.check b/test/files/run/kind-repl-command.check index 1c292572e6..586b2710e1 100644 --- a/test/files/run/kind-repl-command.check +++ b/test/files/run/kind-repl-command.check @@ -25,4 +25,4 @@ scala> :k Nonexisting Nonexisting ^ -scala> +scala> :quit diff --git a/test/files/run/large_class.check b/test/files/run/large_class.check new file mode 100644 index 0000000000..0585c267ac --- /dev/null +++ b/test/files/run/large_class.check @@ -0,0 +1,3 @@ +newSource1.scala:1: error: Could not write class BigEnoughToFail because it exceeds JVM code size limits. Class file too large! +class BigEnoughToFail { + ^ diff --git a/test/files/run/large_class.scala b/test/files/run/large_class.scala new file mode 100644 index 0000000000..aa486ef8f7 --- /dev/null +++ b/test/files/run/large_class.scala @@ -0,0 +1,27 @@ +import scala.tools.partest._ +import java.io.{Console => _, _} + +// a cold run of partest takes about 15s for this test on my laptop +object Test extends DirectTest { + override def extraSettings: String = "-usejavacp -d " + testOutput.path + + def s(n: Int) = "\""+n+"\"" + + override def code + = s""" + |class BigEnoughToFail { + | def m(a: String, b: String, c: String, d: String, e: String, f: String) = null + | ${(1 to 5500) map (n => "def f"+n+" = m("+ s(n+10000)+","+ + s(n+20000)+","+ + s(n+30000)+","+ + s(n+40000)+","+ + s(n+50000)+","+ + s(n+60000)+")") mkString ";"} + |}""".stripMargin.trim + + override def show(): Unit = { + Console.withErr(System.out) { + compile() + } + } +} diff --git a/test/files/run/literals.check b/test/files/run/literals.check index ed7c6ca5b3..092340eead 100644 --- a/test/files/run/literals.check +++ b/test/files/run/literals.check @@ -1,57 +1,12 @@ -warning: there were 5 deprecation warning(s); re-run with -deprecation for details -test '\u0024' == '$' was successful -test '\u005f' == '_' was successful -test 65.asInstanceOf[Char] == 'A' was successful -test "\141\142" == "ab" was successful -test "\0x61\0x62".trim() == "x61\0x62" was successful - -test (65 : Byte) == 'A' was successful - -test 0X01 == 1 was successful -test 0x01 == 1 was successful -test 0x10 == 16 was successful -test 0xa == 10 was successful -test 0x0a == 10 was successful -test +0x01 == 1 was successful -test +0x10 == 16 was successful -test +0xa == 10 was successful -test +0x0a == 10 was successful -test -0x01 == -1 was successful -test -0x10 == -16 was successful -test -0xa == -10 was successful -test -0x0a == -10 was successful -test 0x7fffffff == 2147483647 was successful -test 0x80000000 == -2147483648 was successful -test 0xffffffff == -1 was successful - -test 1l == 1L was successful -test 1L == 1l was successful -test 1.asInstanceOf[Long] == 1l was successful -test 0x7fffffffffffffffL == 9223372036854775807L was successful -test 0x8000000000000000L == -9223372036854775808L was successful -test 0xffffffffffffffffL == -1L was successful - -test 1e1f == 10.0f was successful -test .3f == 0.3f was successful -test 0f == 0.0f was successful -test 01.23f == 1.23f was successful -test 3.14f == 3.14f was successful -test 6.022e23f == 6.022e23f was successful -test 09f == 9.0f was successful -test 1.asInstanceOf[Float] == 1.0 was successful -test 1l.asInstanceOf[Float] == 1.0 was successful - -test 1e1 == 10.0 was successful -test .3 == 0.3 was successful -test 0.0 == 0.0 was successful -test 0d == 0.0 was successful -test 01.23 == 1.23 was successful -test 01.23d == 1.23d was successful -test 3.14 == 3.14 was successful -test 1e-9d == 1.0e-9 was successful -test 1e137 == 1.0e137 was successful -test 1.asInstanceOf[Double] == 1.0 was successful -test 1l.asInstanceOf[Double] == 1.0 was successful - -test "".length() was successful -test ggg == 3 was successful +literals.scala:34: warning: Octal escape literals are deprecated, use \u0061 instead. + check_success("\"\\141\\142\" == \"ab\"", "\141\142", "ab") + ^ +literals.scala:34: warning: Octal escape literals are deprecated, use \u0062 instead. + check_success("\"\\141\\142\" == \"ab\"", "\141\142", "ab") + ^ +literals.scala:37: warning: Octal escape literals are deprecated, use \u0000 instead. + "\0x61\0x62".getBytes(io.Codec.UTF8.charSet) sameElements Array[Byte](0, 120, 54, 49, 0, 120, 54, 50), + ^ +literals.scala:37: warning: Octal escape literals are deprecated, use \u0000 instead. + "\0x61\0x62".getBytes(io.Codec.UTF8.charSet) sameElements Array[Byte](0, 120, 54, 49, 0, 120, 54, 50), + ^ diff --git a/test/files/run/literals.flags b/test/files/run/literals.flags new file mode 100644 index 0000000000..dcc59ebe32 --- /dev/null +++ b/test/files/run/literals.flags @@ -0,0 +1 @@ +-deprecation diff --git a/test/files/run/literals.scala b/test/files/run/literals.scala index 5f23e6b492..13fda05876 100644 --- a/test/files/run/literals.scala +++ b/test/files/run/literals.scala @@ -14,21 +14,16 @@ object Test { def \u03b1\u03b1(that: GGG) = i + that.i } - def check_success[a](name: String, closure: => a, expected: a) { - print("test " + name) - try { - val actual: a = closure - if (actual == expected) { - print(" was successful"); - } else { - print(" failed: expected "+ expected +", found "+ actual); + def check_success[A](name: String, closure: => A, expected: A) { + val res: Option[String] = + try { + val actual: A = closure + if (actual == expected) None //print(" was successful") + else Some(s" failed: expected $expected, found $actual") + } catch { + case exception: Throwable => Some(s" raised exception $exception") } - } catch { - case exception: Throwable => { - print(" raised exception " + exception); - } - } - println + for (e <- res) println(s"test $name $e") } def main(args: Array[String]) { @@ -37,15 +32,14 @@ object Test { check_success("'\\u005f' == '_'", '\u005f', '_') check_success("65.asInstanceOf[Char] == 'A'", 65.asInstanceOf[Char], 'A') check_success("\"\\141\\142\" == \"ab\"", "\141\142", "ab") - check_success("\"\\0x61\\0x62\".trim() == \"x61\\0x62\"", "\0x61\0x62".substring(1), "x61\0x62") - - println + //check_success("\"\\0x61\\0x62\".trim() == \"x61\\0x62\"", "\0x61\0x62".substring(1), "x61\0x62") + check_success(""""\0x61\0x62".getBytes == Array(0, 120, ...)""", + "\0x61\0x62".getBytes(io.Codec.UTF8.charSet) sameElements Array[Byte](0, 120, 54, 49, 0, 120, 54, 50), + true) // boolean check_success("(65 : Byte) == 'A'", (65: Byte) == 'A', true) // contrib #176 - println - // int check_success("0X01 == 1", 0X01, 1) check_success("0x01 == 1", 0x01, 1) @@ -67,8 +61,6 @@ object Test { check_success("0x80000000 == -2147483648", 0x80000000, -2147483648) check_success("0xffffffff == -1", 0xffffffff, -1) - println - // long check_success("1l == 1L", 1l, 1L) check_success("1L == 1l", 1L, 1l) @@ -81,8 +73,6 @@ object Test { check_success("0xffffffffffffffffL == -1L", 0xffffffffffffffffL, -1L) - println - // see JLS at address: // http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#230798 @@ -97,8 +87,6 @@ object Test { check_success("1.asInstanceOf[Float] == 1.0", 1.asInstanceOf[Float], 1.0f) check_success("1l.asInstanceOf[Float] == 1.0", 1l.asInstanceOf[Float], 1.0f) - println - // double check_success("1e1 == 10.0", 1e1, 10.0) check_success(".3 == 0.3", .3, 0.3) @@ -112,7 +100,6 @@ object Test { check_success("1.asInstanceOf[Double] == 1.0", 1.asInstanceOf[Double], 1.0) check_success("1l.asInstanceOf[Double] == 1.0", 1l.asInstanceOf[Double], 1.0) - println check_success("\"\".length()", "\u001a".length(), 1) val ggg = GGG(1) \u03b1\u03b1 GGG(2) diff --git a/test/files/run/lub-visibility.check b/test/files/run/lub-visibility.check index f76579412e..70734966f0 100644 --- a/test/files/run/lub-visibility.check +++ b/test/files/run/lub-visibility.check @@ -8,4 +8,4 @@ scala> // but reverted that for SI-5534. scala> val x = List(List(), Vector()) x: List[scala.collection.immutable.Seq[Nothing] with scala.collection.AbstractSeq[Nothing] with java.io.Serializable] = List(List(), Vector()) -scala> +scala> :quit diff --git a/test/files/run/macro-bundle-repl.check b/test/files/run/macro-bundle-repl.check index 4a0b421606..75c5c2adda 100644 --- a/test/files/run/macro-bundle-repl.check +++ b/test/files/run/macro-bundle-repl.check @@ -21,4 +21,4 @@ defined term macro foo: Unit scala> foo -scala> +scala> :quit diff --git a/test/files/run/macro-openmacros.flags b/test/files/run/macro-openmacros.flags index cd66464f2f..2433c055a4 100644 --- a/test/files/run/macro-openmacros.flags +++ b/test/files/run/macro-openmacros.flags @@ -1 +1,2 @@ --language:experimental.macros
\ No newline at end of file +-Yrangepos:false +-language:experimental.macros diff --git a/test/files/run/macro-parse-position.flags b/test/files/run/macro-parse-position.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/run/macro-parse-position.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/macro-rangepos-args.check b/test/files/run/macro-rangepos-args.check new file mode 100644 index 0000000000..d779505c66 --- /dev/null +++ b/test/files/run/macro-rangepos-args.check @@ -0,0 +1 @@ +Line: 3. Width: 5. diff --git a/test/files/run/macro-rangepos-args.flags b/test/files/run/macro-rangepos-args.flags new file mode 100644 index 0000000000..fcf951d907 --- /dev/null +++ b/test/files/run/macro-rangepos-args.flags @@ -0,0 +1 @@ +-Yrangepos
\ No newline at end of file diff --git a/test/files/run/macro-rangepos-args/Macros_1.scala b/test/files/run/macro-rangepos-args/Macros_1.scala new file mode 100644 index 0000000000..97b938613c --- /dev/null +++ b/test/files/run/macro-rangepos-args/Macros_1.scala @@ -0,0 +1,10 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.Context + +object Macros { + def impl(c: Context)(x: c.Tree): c.Tree = { + import c.universe._ + Literal(Constant(s"Line: ${x.pos.line}. Width: ${x.pos.end - x.pos.start}.")) + } + def pos(x: Any): String = macro impl +} diff --git a/test/files/run/macro-rangepos-args/Test_2.scala b/test/files/run/macro-rangepos-args/Test_2.scala new file mode 100644 index 0000000000..8c770e9010 --- /dev/null +++ b/test/files/run/macro-rangepos-args/Test_2.scala @@ -0,0 +1,4 @@ +object Test extends App { + val x = 2 + println(Macros.pos(x + 2)) +}
\ No newline at end of file diff --git a/test/files/run/macro-rangepos-subpatterns.check b/test/files/run/macro-rangepos-subpatterns.check new file mode 100644 index 0000000000..760e15d019 --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns.check @@ -0,0 +1 @@ +The width of the subpattern is: 2 diff --git a/test/files/run/macro-rangepos-subpatterns.flags b/test/files/run/macro-rangepos-subpatterns.flags new file mode 100644 index 0000000000..fcf951d907 --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns.flags @@ -0,0 +1 @@ +-Yrangepos
\ No newline at end of file diff --git a/test/files/run/macro-rangepos-subpatterns/Macros_1.scala b/test/files/run/macro-rangepos-subpatterns/Macros_1.scala new file mode 100644 index 0000000000..0f30862347 --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns/Macros_1.scala @@ -0,0 +1,18 @@ +import scala.reflect.macros.whitebox.Context +import language.experimental.macros + +object Extractor { + def unapply(x: Any): Any = macro unapplyImpl + def unapplyImpl(c: Context)(x: c.Tree) = { + import c.universe._ + import internal._ + val pos = subpatterns(x).get.head.pos + q""" + new { + def isEmpty = false + def get = ${"The width of the subpattern is: " + (pos.end - pos.start + 1)} + def unapply(x: Any) = this + }.unapply($x) + """ + } +} diff --git a/test/files/run/macro-rangepos-subpatterns/Test_2.scala b/test/files/run/macro-rangepos-subpatterns/Test_2.scala new file mode 100644 index 0000000000..7b076e6632 --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns/Test_2.scala @@ -0,0 +1,5 @@ +object Test extends App { + 42 match { + case Extractor(a) => println(a) + } +} diff --git a/test/files/run/macro-repl-basic.check b/test/files/run/macro-repl-basic.check index 86b4d472ed..fab03d1558 100644 --- a/test/files/run/macro-repl-basic.check +++ b/test/files/run/macro-repl-basic.check @@ -49,4 +49,4 @@ import Macros.Shmacros._ scala> println(foo(2) + Macros.bar(2) * new Macros().quux(4)) 31 -scala> +scala> :quit diff --git a/test/files/run/macro-repl-dontexpand.check b/test/files/run/macro-repl-dontexpand.check index 20d3b2d702..6ecc9245fa 100644 --- a/test/files/run/macro-repl-dontexpand.check +++ b/test/files/run/macro-repl-dontexpand.check @@ -13,4 +13,4 @@ bar2: (c: scala.reflect.macros.whitebox.Context)Nothing scala> def foo2 = macro bar2 defined term macro foo2: Nothing -scala> +scala> :quit diff --git a/test/files/run/macro-system-properties.check b/test/files/run/macro-system-properties.check index ffbd5a8aa8..e2e2bd32b9 100644 --- a/test/files/run/macro-system-properties.check +++ b/test/files/run/macro-system-properties.check @@ -19,4 +19,4 @@ defined object Test scala> object Test { class C(implicit a: Any) { GrabContext.grab } } defined object Test -scala> +scala> :quit diff --git a/test/files/run/macroPlugins-enterStats.check b/test/files/run/macroPlugins-enterStats.check new file mode 100644 index 0000000000..133b1ae1af --- /dev/null +++ b/test/files/run/macroPlugins-enterStats.check @@ -0,0 +1,30 @@ +[[syntax trees at end of typer]] // newSource1.scala +package <empty> { + class C extends scala.AnyRef { + def <init>(): C = { + C.super.<init>(); + () + }; + def x: Int = 2; + def xmacroPlugin1: Nothing = scala.this.Predef.???; + def xmacroPlugin2: Nothing = scala.this.Predef.???; + def xmacroPlugin2macroPlugin1: Nothing = scala.this.Predef.???; + def y: Int = 3; + def ymacroPlugin1: Nothing = scala.this.Predef.???; + def ymacroPlugin2: Nothing = scala.this.Predef.???; + def ymacroPlugin2macroPlugin1: Nothing = scala.this.Predef.??? + } +} + +macroPlugin2:enterStat(class C extends scala.AnyRef { def <init>() = { super.<init>(); () }; def x = 2; def y = 3 }) +macroPlugin1:enterStat(class C extends scala.AnyRef { def <init>() = { super.<init>(); () }; def x = 2; def y = 3 }) +macroPlugin2:enterStat(def <init>() = { super.<init>(); () }) +macroPlugin2:enterStat(def x = 2) +macroPlugin2:enterStat(def y = 3) +macroPlugin1:enterStat(def <init>() = { super.<init>(); () }) +macroPlugin1:enterStat(def x = 2) +macroPlugin1:enterStat(def xmacroPlugin2 = $qmark$qmark$qmark) +macroPlugin1:enterStat(def y = 3) +macroPlugin1:enterStat(def ymacroPlugin2 = $qmark$qmark$qmark) +macroPlugin2:enterStat(super.<init>()) +macroPlugin1:enterStat(super.<init>()) diff --git a/test/files/run/macroPlugins-enterStats.scala b/test/files/run/macroPlugins-enterStats.scala new file mode 100644 index 0000000000..917233e990 --- /dev/null +++ b/test/files/run/macroPlugins-enterStats.scala @@ -0,0 +1,50 @@ +import scala.tools.partest._ +import scala.tools.nsc._ + +object Test extends DirectTest { + override def extraSettings: String = "-usejavacp -Xprint:typer" + + def code = """ + class C { + def x = 2 + def y = 3 + } + """.trim + + def show() { + val global = newCompiler() + import global._ + import analyzer._ + + val output = collection.mutable.ListBuffer[String]() + def log(what: String) = output += what.replace(String.format("%n"), " ") + + def logEnterStat(pluginName: String, stat: Tree): Unit = log(s"$pluginName:enterStat($stat)") + def deriveStat(pluginName: String, typer: Typer, stat: Tree): List[Tree] = stat match { + case DefDef(mods, name, Nil, Nil, TypeTree(), body) => + val derived = DefDef(NoMods, TermName(name + pluginName), Nil, Nil, TypeTree(), Ident(TermName("$qmark$qmark$qmark"))) + newNamer(typer.context).enterSym(derived) + List(derived) + case _ => + Nil + } + + object macroPlugin1 extends MacroPlugin { + override def pluginsEnterStats(typer: Typer, stats: List[Tree]): List[Tree] = { + stats.foreach(stat => logEnterStat("macroPlugin1", stat)) + stats.flatMap(stat => stat +: deriveStat("macroPlugin1", typer, stat)) + } + } + object macroPlugin2 extends MacroPlugin { + override def pluginsEnterStats(typer: Typer, stats: List[Tree]): List[Tree] = { + stats.foreach(stat => logEnterStat("macroPlugin2", stat)) + stats.flatMap(stat => stat +: deriveStat("macroPlugin2", typer, stat)) + } + } + + addMacroPlugin(macroPlugin1) + addMacroPlugin(macroPlugin2) + compileString(global)(code) + println(output.mkString("\n")) + } +} diff --git a/test/files/run/macroPlugins-isBlackbox/Macros_2.scala b/test/files/run/macroPlugins-isBlackbox/Macros_2.scala new file mode 100644 index 0000000000..a90dd702df --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Macros_2.scala @@ -0,0 +1,11 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.Context + +object Macros { + def impl(c: Context) = { + import c.universe._ + q"42" + } + + def foo: Any = macro impl +}
\ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/Plugin_1.scala b/test/files/run/macroPlugins-isBlackbox/Plugin_1.scala new file mode 100644 index 0000000000..b78a18ea6a --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Plugin_1.scala @@ -0,0 +1,21 @@ +package isblackbox + +import scala.tools.nsc.Global +import scala.tools.nsc.plugins.{Plugin => NscPlugin} + +class Plugin(val global: Global) extends NscPlugin { + import global._ + import analyzer._ + import scala.reflect.internal.Mode + + val name = "isBlackbox" + val description = "A sample analyzer plugin that overrides isBlackbox." + val components = Nil + addMacroPlugin(MacroPlugin) + + object MacroPlugin extends MacroPlugin { + override def pluginsIsBlackbox(macroDef: Symbol): Option[Boolean] = { + Some(false) + } + } +}
\ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/Test_3.flags b/test/files/run/macroPlugins-isBlackbox/Test_3.flags new file mode 100644 index 0000000000..966df731d0 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Test_3.flags @@ -0,0 +1 @@ +-Xplugin:.
\ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/Test_3.scala b/test/files/run/macroPlugins-isBlackbox/Test_3.scala new file mode 100644 index 0000000000..552e888143 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Test_3.scala @@ -0,0 +1,3 @@ +object Test extends App { + val x: Int = Macros.foo +}
\ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/scalac-plugin.xml b/test/files/run/macroPlugins-isBlackbox/scalac-plugin.xml new file mode 100644 index 0000000000..09b9c14648 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/scalac-plugin.xml @@ -0,0 +1,4 @@ +<plugin> + <name>is-blackbox</name> + <classname>isblackbox.Plugin</classname> +</plugin>
\ No newline at end of file diff --git a/test/files/run/macroPlugins-macroExpand.flags b/test/files/run/macroPlugins-macroExpand.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/run/macroPlugins-macroExpand.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/macroPlugins-typedMacroBody.flags b/test/files/run/macroPlugins-typedMacroBody.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/run/macroPlugins-typedMacroBody.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/mapConserve.scala b/test/files/run/mapConserve.scala index d1d52f3107..c17754283a 100644 --- a/test/files/run/mapConserve.scala +++ b/test/files/run/mapConserve.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with */ import scala.annotation.tailrec import scala.collection.mutable.ListBuffer diff --git a/test/files/run/names-defaults.check b/test/files/run/names-defaults.check index 0037822f3b..c358dc5849 100644 --- a/test/files/run/names-defaults.check +++ b/test/files/run/names-defaults.check @@ -1,7 +1,7 @@ names-defaults.scala:269: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses spawn(b = { val ttt = 1; ttt }, a = 0) ^ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details 1: @ get: $ get: 2 @@ -124,3 +124,4 @@ List(1, 2) 3 3 (1,0), (1,2) +1 1 0 diff --git a/test/files/run/names-defaults.scala b/test/files/run/names-defaults.scala index 05cd4a540c..b7ed490cbc 100644 --- a/test/files/run/names-defaults.scala +++ b/test/files/run/names-defaults.scala @@ -401,6 +401,10 @@ object Test extends App { C4441a().copy() C4441b()().copy()() + // SI-8117 + def f8177(a: Int = 0, b: Int = 0, c: Int = 0) = s"$a $b $c" + println(f8177(a = 1, 1)) + // DEFINITIONS def test1(a: Int, b: String) = println(a +": "+ b) def test2(u: Int, v: Int)(k: String, l: Int) = println(l +": "+ k +", "+ (u + v)) diff --git a/test/files/run/nothingTypeDce.flags b/test/files/run/nothingTypeDce.flags new file mode 100644 index 0000000000..d85321ca0e --- /dev/null +++ b/test/files/run/nothingTypeDce.flags @@ -0,0 +1 @@ +-target:jvm-1.6 -Ybackend:GenBCode -Yopt:unreachable-code diff --git a/test/files/run/nothingTypeDce.scala b/test/files/run/nothingTypeDce.scala new file mode 100644 index 0000000000..5f3692fd33 --- /dev/null +++ b/test/files/run/nothingTypeDce.scala @@ -0,0 +1,63 @@ +// See comment in BCodeBodyBuilder + +// -target:jvm-1.6 -Ybackend:GenBCode -Yopt:unreachable-code +// target enables stack map frames generation + +class C { + // can't just emit a call to ???, that returns value of type Nothing$ (not Int). + def f1: Int = ??? + + def f2: Int = throw new Error("") + + def f3(x: Boolean) = { + var y = 0 + // cannot assign an object of type Nothing$ to Int + if (x) y = ??? + else y = 1 + y + } + + def f4(x: Boolean) = { + var y = 0 + // tests that whatever is emitted after the throw is valid (what? depends on opts, presence of stack map frames) + if (x) y = throw new Error("") + else y = 1 + y + } + + def f5(x: Boolean) = { + // stack heights need to be the same. ??? looks to the jvm like returning a value of + // type Nothing$, need to drop or throw it. + println( + if (x) { ???; 10 } + else 20 + ) + } + + def f6(x: Boolean) = { + println( + if (x) { throw new Error(""); 10 } + else 20 + ) + } + + def f7(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } + + def f8(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } +} + +object Test extends App { + // creating an instance is enough to trigger bytecode verification for all methods, + // no need to invoke the methods. + new C() +} diff --git a/test/files/run/nothingTypeNoFramesNoDce.check b/test/files/run/nothingTypeNoFramesNoDce.check new file mode 100644 index 0000000000..b1d08b45ff --- /dev/null +++ b/test/files/run/nothingTypeNoFramesNoDce.check @@ -0,0 +1 @@ +warning: -target:jvm-1.5 is deprecated: use target for Java 1.6 or above. diff --git a/test/files/run/nothingTypeNoFramesNoDce.flags b/test/files/run/nothingTypeNoFramesNoDce.flags new file mode 100644 index 0000000000..a035c86179 --- /dev/null +++ b/test/files/run/nothingTypeNoFramesNoDce.flags @@ -0,0 +1 @@ +-target:jvm-1.5 -Ybackend:GenBCode -Yopt:l:none -deprecation diff --git a/test/files/run/nothingTypeNoFramesNoDce.scala b/test/files/run/nothingTypeNoFramesNoDce.scala new file mode 100644 index 0000000000..3d1298303a --- /dev/null +++ b/test/files/run/nothingTypeNoFramesNoDce.scala @@ -0,0 +1,61 @@ +// See comment in BCodeBodyBuilder + +// -target:jvm-1.5 -Ybackend:GenBCode -Yopt:l:none +// target disables stack map frame generation. in this mode, the ClssWriter just emits dead code as is. + +class C { + // can't just emit a call to ???, that returns value of type Nothing$ (not Int). + def f1: Int = ??? + + def f2: Int = throw new Error("") + + def f3(x: Boolean) = { + var y = 0 + // cannot assign an object of type Nothing$ to Int + if (x) y = ??? + else y = 1 + y + } + + def f4(x: Boolean) = { + var y = 0 + // tests that whatever is emitted after the throw is valid (what? depends on opts, presence of stack map frames) + if (x) y = throw new Error("") + else y = 1 + y + } + + def f5(x: Boolean) = { + // stack heights need to be the smae. ??? looks to the jvm like returning a value of + // type Nothing$, need to drop or throw it. + println( + if (x) { ???; 10 } + else 20 + ) + } + + def f6(x: Boolean) = { + println( + if (x) { throw new Error(""); 10 } + else 20 + ) + } + + def f7(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } + + def f8(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } +} + +object Test extends App { + new C() +} diff --git a/test/files/run/nothingTypeNoOpt.flags b/test/files/run/nothingTypeNoOpt.flags new file mode 100644 index 0000000000..b3b518051b --- /dev/null +++ b/test/files/run/nothingTypeNoOpt.flags @@ -0,0 +1 @@ +-target:jvm-1.6 -Ybackend:GenBCode -Yopt:l:none diff --git a/test/files/run/nothingTypeNoOpt.scala b/test/files/run/nothingTypeNoOpt.scala new file mode 100644 index 0000000000..5c5a20fa3b --- /dev/null +++ b/test/files/run/nothingTypeNoOpt.scala @@ -0,0 +1,61 @@ +// See comment in BCodeBodyBuilder + +// -target:jvm-1.6 -Ybackend:GenBCode -Yopt:l:none +// target enables stack map frame generation + +class C { + // can't just emit a call to ???, that returns value of type Nothing$ (not Int). + def f1: Int = ??? + + def f2: Int = throw new Error("") + + def f3(x: Boolean) = { + var y = 0 + // cannot assign an object of type Nothing$ to Int + if (x) y = ??? + else y = 1 + y + } + + def f4(x: Boolean) = { + var y = 0 + // tests that whatever is emitted after the throw is valid (what? depends on opts, presence of stack map frames) + if (x) y = throw new Error("") + else y = 1 + y + } + + def f5(x: Boolean) = { + // stack heights need to be the smae. ??? looks to the jvm like returning a value of + // type Nothing$, need to drop or throw it. + println( + if (x) { ???; 10 } + else 20 + ) + } + + def f6(x: Boolean) = { + println( + if (x) { throw new Error(""); 10 } + else 20 + ) + } + + def f7(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } + + def f8(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } +} + +object Test extends App { + new C() +} diff --git a/test/files/run/pc-conversions.scala b/test/files/run/pc-conversions.scala index 19fef355c8..d4ae305aa7 100644 --- a/test/files/run/pc-conversions.scala +++ b/test/files/run/pc-conversions.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warning; re-run with */ import collection._ diff --git a/test/files/run/priorityQueue.scala b/test/files/run/priorityQueue.scala deleted file mode 100644 index 327d8bf137..0000000000 --- a/test/files/run/priorityQueue.scala +++ /dev/null @@ -1,373 +0,0 @@ - - - -import scala.collection.mutable.PriorityQueue - - - - - - -// populate a priority queue a few different ways and make sure they all seem equal -object Test { - - def main(args: Array[String]) { - // testInsertionsAndEqualities - // testIntensiveEnqueueDequeue - // testTails - // testInits - // testFilters - // testDrops - // testEquality - // testMisc - // testReverse - // testToList - // testForeach - } - - // def testInsertionsAndEqualities { - // import scala.util.Random.nextInt - // val pq1 = new PriorityQueue[String] - // val pq2 = new PriorityQueue[String] - // val pq3 = new PriorityQueue[String] - // val pq4 = new PriorityQueue[String] - - // val strings = (1 to 20).toList map (i => List.fill((Math.abs(nextInt % 20)) + 1)("x").mkString) - - // pq1 ++= strings - // pq2 ++= strings.reverse - // for (s <- strings) pq3 += s - // for (s <- strings.reverse) pq4 += s - - // val pqs = List(pq1, pq2, pq3, pq4, pq1.clone, pq2.clone) - - // for (queue1 <- pqs ; queue2 <- pqs) { - // val l1: List[String] = queue1.dequeueAll[String, List[String]] - // val l2: List[String] = queue2.dequeueAll[String, List[String]] - // assert(l1 == l2) - // assert(queue1.max == queue2.max) - // } - - // assertPriorityDestructive(pq1) - // } - - // not a sequence anymore, Mildred - // def testIndexing { - // val pq = new PriorityQueue[Char] - // "The quick brown fox jumps over the lazy dog".foreach(pq += _) - - // // val iter = pq.iterator - // // while (iter.hasNext) println("`" + iter.next + "`") - // assert(pq(0) == 'z') - // assert(pq(1) == 'y') - // assert(pq(2) == 'x') - // assert(pq(3) == 'w') - // assert(pq(4) == 'v') - // assert(pq(5) == 'u') - // assert(pq(7) == 't') - // assert(pq(8) == 's') - // assert(pq(9) == 'r') - // assert(pq(10) == 'r') - - // pq.clear - // "abcdefghijklmnopqrstuvwxyz".foreach(pq += _) - // for (i <- 0 until 26) assert(pq(i) == ('z' - i)) - - // val intpq = new PriorityQueue[Int] - // val intlst = new collection.mutable.ArrayBuffer ++ (0 until 100) - // val random = new util.Random(101) - // while (intlst.nonEmpty) { - // val idx = random.nextInt(intlst.size) - // intpq += intlst(idx) - // intlst.remove(idx) - // } - // for (i <- 0 until 100) assert(intpq(i) == (99 - i)) - // } - - // def testTails { - // val pq = new PriorityQueue[Int] - // for (i <- 0 until 10) pq += i * 4321 % 200 - - // assert(pq.size == 10) - // assert(pq.nonEmpty) - - // val tailpq = pq.tail - // // pq.printstate - // // tailpq.printstate - // assert(tailpq.size == 9) - // assert(tailpq.nonEmpty) - // assertPriorityDestructive(tailpq) - // } - - // def assertPriorityDestructive[A](pq: PriorityQueue[A])(implicit ord: Ordering[A]) { - // import ord._ - // var prev: A = null.asInstanceOf[A] - // while (pq.nonEmpty) { - // val curr = pq.dequeue - // if (prev != null) assert(curr <= prev) - // prev = curr - // } - // } - - // def testInits { - // val pq = new PriorityQueue[Long] - // for (i <- 0 until 20) pq += (i + 313) * 111 % 300 - - // assert(pq.size == 20) - - // val initpq = pq.init - // assert(initpq.size == 19) - // assertPriorityDestructive(initpq) - // } - - // def testFilters { - // val pq = new PriorityQueue[String] - // for (i <- 0 until 100) pq += "Some " + (i * 312 % 200) - - // val filpq = pq.filter(_.indexOf('0') != -1) - // assertPriorityDestructive(filpq) - // } - - // def testIntensiveEnqueueDequeue { - // val pq = new PriorityQueue[Int] - - // testIntensive(1000, pq) - // pq.clear - // testIntensive(200, pq) - // } - - // def testIntensive(sz: Int, pq: PriorityQueue[Int]) { - // val lst = new collection.mutable.ArrayBuffer[Int] ++ (0 until sz) - // val rand = new util.Random(7) - // while (lst.nonEmpty) { - // val idx = rand.nextInt(lst.size) - // pq.enqueue(lst(idx)) - // lst.remove(idx) - // if (rand.nextDouble < 0.25 && pq.nonEmpty) pq.dequeue - // assertPriority(pq) - // } - // } - - // def testDrops { - // val pq = new PriorityQueue[Int] - // pq ++= (0 until 100) - // val droppq = pq.drop(50) - // assertPriority(droppq) - - // pq.clear - // pq ++= droppq - // assertPriorityDestructive(droppq) - // assertPriority(pq) - // assertPriorityDestructive(pq) - // } - - // // your sequence days have ended, foul priority queue - // // def testUpdates { - // // val pq = new PriorityQueue[Int] - // // pq ++= (0 until 36) - // // assertPriority(pq) - - // // pq(0) = 100 - // // assert(pq(0) == 100) - // // assert(pq.dequeue == 100) - // // assertPriority(pq) - - // // pq.clear - - // // pq ++= (1 to 100) - // // pq(5) = 200 - // // assert(pq(0) == 200) - // // assert(pq(1) == 100) - // // assert(pq(2) == 99) - // // assert(pq(3) == 98) - // // assert(pq(4) == 97) - // // assert(pq(5) == 96) - // // assert(pq(6) == 94) - // // assert(pq(7) == 93) - // // assert(pq(98) == 2) - // // assert(pq(99) == 1) - // // assertPriority(pq) - - // // pq(99) = 450 - // // assert(pq(0) == 450) - // // assert(pq(1) == 200) - // // assert(pq(99) == 2) - // // assertPriority(pq) - - // // pq(1) = 0 - // // assert(pq(1) == 100) - // // assert(pq(99) == 0) - // // assertPriority(pq) - // // assertPriorityDestructive(pq) - // // } - - // def testEquality { - // val pq1 = new PriorityQueue[Int] - // val pq2 = new PriorityQueue[Int] - - // pq1 ++= (0 until 50) - // var i = 49 - // while (i >= 0) { - // pq2 += i - // i -= 1 - // } - // assert(pq1 == pq2) - // assertPriority(pq2) - - // pq1 += 100 - // assert(pq1 != pq2) - // pq2 += 100 - // assert(pq1 == pq2) - // pq2 += 200 - // assert(pq1 != pq2) - // pq1 += 200 - // assert(pq1 == pq2) - // assertPriorityDestructive(pq1) - // assertPriorityDestructive(pq2) - // } - - // def testMisc { - // val pq = new PriorityQueue[Int] - // pq ++= (0 until 100) - // assert(pq.size == 100) - - // val (p1, p2) = pq.partition(_ < 50) - // assertPriorityDestructive(p1) - // assertPriorityDestructive(p2) - - // val spq = pq.slice(25, 75) - // assertPriorityDestructive(spq) - - // pq.clear - // pq ++= (0 until 10) - // pq += 5 - // assert(pq.size == 11) - - // val ind = pq.lastIndexWhere(_ == 5) - // assert(ind == 5) - // assertPriorityDestructive(pq) - - // pq.clear - // pq ++= (0 until 10) - // assert(pq.lastIndexWhere(_ == 9) == 0) - // assert(pq.lastIndexOf(8) == 1) - // assert(pq.lastIndexOf(7) == 2) - - // pq += 5 - // pq += 9 - // assert(pq.lastIndexOf(9) == 1) - // assert(pq.lastIndexWhere(_ % 2 == 1) == 10) - // assert(pq.lastIndexOf(5) == 6) - - // val lst = pq.reverseIterator.toList - // for (i <- 0 until 5) assert(lst(i) == i) - // assert(lst(5) == 5) - // assert(lst(6) == 5) - // assert(lst(7) == 6) - // assert(lst(8) == 7) - // assert(lst(9) == 8) - // assert(lst(10) == 9) - // assert(lst(11) == 9) - - // pq.clear - // assert(pq.reverseIterator.toList.isEmpty) - - // pq ++= (50 to 75) - // assert(pq.lastIndexOf(70) == 5) - - // pq += 55 - // pq += 70 - // assert(pq.lastIndexOf(70) == 6) - // assert(pq.lastIndexOf(55) == 22) - // assert(pq.lastIndexOf(55, 21) == 21) - // assert(pq.lastIndexWhere(_ > 54) == 22) - // assert(pq.lastIndexWhere(_ > 54, 21) == 21) - // assert(pq.lastIndexWhere(_ > 69, 5) == 5) - // } - - // def testReverse { - // val pq = new PriorityQueue[(Int, Int)] - // pq ++= (for (i <- 0 until 10) yield (i, i * i % 10)) - - // assert(pq.reverse.size == pq.reverseIterator.toList.size) - // assert((pq.reverse zip pq.reverseIterator.toList).forall(p => p._1 == p._2)) - // assert(pq.reverse.sameElements(pq.reverseIterator.toSeq)) - // assert(pq.reverse(0)._1 == pq(9)._1) - // assert(pq.reverse(1)._1 == pq(8)._1) - // assert(pq.reverse(4)._1 == pq(5)._1) - // assert(pq.reverse(9)._1 == pq(0)._1) - - // pq += ((7, 7)) - // pq += ((7, 9)) - // pq += ((7, 8)) - // assert(pq.reverse.reverse == pq) - // assert(pq.reverse.lastIndexWhere(_._2 == 6) == 6) - // assertPriorityDestructive(pq.reverse.reverse) - - // val iq = new PriorityQueue[Int] - // iq ++= (0 until 50) - // assert(iq.reverse == iq.reverseIterator.toSeq) - // assert(iq.reverse.reverse == iq) - - // iq += 25 - // iq += 40 - // iq += 10 - // assert(iq.reverse == iq.reverseIterator.toList) - // assert(iq.reverse.reverse == iq) - // assert(iq.reverse.lastIndexWhere(_ == 10) == 11) - // assertPriorityDestructive(iq.reverse.reverse) - // } - - // def testToList { - // val pq = new PriorityQueue[Int] - - // pq += 1 - // pq += 4 - // pq += 0 - // pq += 5 - // pq += 3 - // pq += 2 - // assert(pq.toList == pq) - // assert(pq == List(5, 4, 3, 2, 1, 0)) - // assert(pq.reverse == List(0, 1, 2, 3, 4, 5)) - - // pq.clear - // for (i <- -50 until 50) pq += i - // assert(pq.toList == pq) - // assert(pq.toList == (-50 until 50).reverse) - // } - - // def testForeach { - // val pq = new PriorityQueue[Char] - - // pq += 't' - // pq += 'o' - // pq += 'b' - // pq += 'y' - // val sbf = new StringBuilder - // val sbi = new StringBuilder - // pq.foreach(sbf += _) - // pq.iterator.foreach(sbi += _) - // assert(sbf.toString == sbi.toString) - // assert(sbf.toString == "ytob") - // } - -} - - - - - - - - - - - - - - - - - - diff --git a/test/files/run/private-override.check b/test/files/run/private-override.check deleted file mode 100644 index 00750edc07..0000000000 --- a/test/files/run/private-override.check +++ /dev/null @@ -1 +0,0 @@ -3 diff --git a/test/files/run/reflection-attachments.check b/test/files/run/reflection-attachments.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/run/reflection-attachments.check diff --git a/test/files/run/reflection-equality.check b/test/files/run/reflection-equality.check index 682326bc18..d60d861a90 100644 --- a/test/files/run/reflection-equality.check +++ b/test/files/run/reflection-equality.check @@ -48,4 +48,4 @@ res2: Boolean = true scala> t2 <:< t1 res3: Boolean = true -scala> +scala> :quit diff --git a/test/files/run/reflection-java-annotations.check b/test/files/run/reflection-java-annotations.check index 72d40989fe..842037254e 100644 --- a/test/files/run/reflection-java-annotations.check +++ b/test/files/run/reflection-java-annotations.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details List(JavaComplexAnnotation_1(v1 = 1, v10 = "hello", v101 = [101, 101], v102 = [102, 102], v103 = ['g', 'g'], v104 = [104, 104], v105 = [105L, 105L], v106 = [106.0, 106.0], v107 = [107.0, 107.0], v108 = [false, true], v11 = classOf[JavaAnnottee_1], v110 = ["hello", "world"], v111 = [classOf[JavaSimpleAnnotation_1], classOf[JavaComplexAnnotation_1]], v112 = [FOO, BAR], v113 = [JavaSimpleAnnotation_1(v1 = 21, v10 = "world2", v11 = classOf[JavaComplexAnnotation_1], v12 = BAR, v2 = 22, v3 = '\027', v4 = 24, v5 = 25L, v6 = 26.0, v7 = 27.0, v8 = false)], v12 = FOO, v13 = JavaSimpleAnnotation_1(v1 = 11, v10 = "world1", v11 = classOf[JavaSimpleAnnotation_1], v12 = FOO, v2 = 12, v3 = '\r', v4 = 14, v5 = 15L, v6 = 16.0, v7 = 17.0, v8 = false), v2 = 2, v3 = '\03', v4 = 4, v5 = 5L, v6 = 6.0, v7 = 7.0, v8 = false)) ======= new JavaComplexAnnotation_1(v1 = 1, v10 = "hello", v101 = Array(101, 101), v102 = Array(102, 102), v103 = Array('g', 'g'), v104 = Array(104, 104), v105 = Array(105L, 105L), v106 = Array(106.0, 106.0), v107 = Array(107.0, 107.0), v108 = Array(false, true), v11 = classOf[JavaAnnottee_1], v110 = Array("hello", "world"), v111 = Array(classOf[JavaSimpleAnnotation_1], classOf[JavaComplexAnnotation_1]), v112 = Array(FOO, BAR), v113 = Array(new JavaSimpleAnnotation_1(v1 = 21, v10 = "world2", v11 = classOf[JavaComplexAnnotation_1], v12 = BAR, v2 = 22, v3 = '\027', v4 = 24, v5 = 25L, v6 = 26.0, v7 = 27.0, v8 = false)), v12 = FOO, v13 = new JavaSimpleAnnotation_1(v1 = 11, v10 = "world1", v11 = classOf[JavaSimpleAnnotation_1], v12 = FOO, v2 = 12, v3 = '\r', v4 = 14, v5 = 15L, v6 = 16.0, v7 = 17.0, v8 = false), v2 = 2, v3 = '\03', v4 = 4, v5 = 5L, v6 = 6.0, v7 = 7.0, v8 = false) diff --git a/test/files/run/reflection-magicsymbols-repl.check b/test/files/run/reflection-magicsymbols-repl.check index a1bee76652..ca8857ada4 100644 --- a/test/files/run/reflection-magicsymbols-repl.check +++ b/test/files/run/reflection-magicsymbols-repl.check @@ -21,7 +21,7 @@ scala> def test(n: Int): Unit = { val x = sig.asInstanceOf[MethodType].params.head println(x.info) } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details test: (n: Int)Unit scala> for (i <- 1 to 8) test(i) @@ -34,4 +34,4 @@ scala.Null scala.Nothing scala.Singleton -scala> +scala> :quit diff --git a/test/files/run/reflection-repl-classes.check b/test/files/run/reflection-repl-classes.check index 03a6aef2b5..5ebf993a87 100644 --- a/test/files/run/reflection-repl-classes.check +++ b/test/files/run/reflection-repl-classes.check @@ -30,4 +30,4 @@ scala> scala> mm(new A) res0: Any = 1 -scala> +scala> :quit diff --git a/test/files/run/reflection-repl-elementary.check b/test/files/run/reflection-repl-elementary.check index 4a223e8a24..e948c9fd61 100644 --- a/test/files/run/reflection-repl-elementary.check +++ b/test/files/run/reflection-repl-elementary.check @@ -4,4 +4,4 @@ Type :help for more information. scala> scala.reflect.runtime.universe.typeOf[List[Nothing]] res0: reflect.runtime.universe.Type = scala.List[Nothing] -scala> +scala> :quit diff --git a/test/files/run/reify-repl-fail-gracefully.check b/test/files/run/reify-repl-fail-gracefully.check index 29ccee3cc6..c9e69744d6 100644 --- a/test/files/run/reify-repl-fail-gracefully.check +++ b/test/files/run/reify-repl-fail-gracefully.check @@ -14,4 +14,4 @@ scala> reify reify ^ -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_22.check b/test/files/run/reify_newimpl_22.check index 1432d10127..952f384a1c 100644 --- a/test/files/run/reify_newimpl_22.check +++ b/test/files/run/reify_newimpl_22.check @@ -22,4 +22,4 @@ scala> { ^ 2 -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_23.check b/test/files/run/reify_newimpl_23.check index 217f0a98c7..b7e9bfdfbc 100644 --- a/test/files/run/reify_newimpl_23.check +++ b/test/files/run/reify_newimpl_23.check @@ -21,4 +21,4 @@ scala> def foo[T]{ ^ foo: [T]=> Unit -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_25.check b/test/files/run/reify_newimpl_25.check index 93ad69defa..4f36ba10ee 100644 --- a/test/files/run/reify_newimpl_25.check +++ b/test/files/run/reify_newimpl_25.check @@ -12,4 +12,4 @@ scala> { ^ TypeTag[x.type] -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_26.check b/test/files/run/reify_newimpl_26.check index 8e0ad87bf2..681b862795 100644 --- a/test/files/run/reify_newimpl_26.check +++ b/test/files/run/reify_newimpl_26.check @@ -14,4 +14,4 @@ foo: [T]=> Unit scala> foo[Int] WeakTypeTag[scala.List[T]] -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_35.check b/test/files/run/reify_newimpl_35.check index f884d2c0d0..bd9b3a2fb1 100644 --- a/test/files/run/reify_newimpl_35.check +++ b/test/files/run/reify_newimpl_35.check @@ -10,4 +10,4 @@ foo: [T](implicit evidence$1: reflect.runtime.universe.TypeTag[T])reflect.runtim scala> println(foo) Expr[List[Nothing]](Nil) -scala> +scala> :quit diff --git a/test/files/run/repl-assign.check b/test/files/run/repl-assign.check index bdc7793c37..faa8a93244 100644 --- a/test/files/run/repl-assign.check +++ b/test/files/run/repl-assign.check @@ -13,4 +13,4 @@ x: Int = 12 scala> y = 13 y: Int = 13 -scala> +scala> :quit diff --git a/test/files/run/repl-bare-expr.check b/test/files/run/repl-bare-expr.check index 97ae208ff4..07cf23412f 100644 --- a/test/files/run/repl-bare-expr.check +++ b/test/files/run/repl-bare-expr.check @@ -47,4 +47,4 @@ Bovine.x: List[Any] = List(Ruminant(5), Cow, Moooooo) scala> Bovine.x res4: List[Any] = List(Ruminant(5), Cow, Moooooo) -scala> +scala> :quit diff --git a/test/files/run/repl-colon-type.check b/test/files/run/repl-colon-type.check index 1f6d3e2b39..9898027c1d 100644 --- a/test/files/run/repl-colon-type.check +++ b/test/files/run/repl-colon-type.check @@ -218,4 +218,4 @@ Unit scala> :type println("side effect!") Unit -scala> +scala> :quit diff --git a/test/files/run/repl-empty-package.check b/test/files/run/repl-empty-package.check index ecf79c2c6d..d3b75f685e 100644 --- a/test/files/run/repl-empty-package.check +++ b/test/files/run/repl-empty-package.check @@ -4,4 +4,4 @@ Type :help for more information. scala> println(Bippy.bippy) bippy! -scala> +scala> :quit diff --git a/test/files/run/repl-javap-app.check b/test/files/run/repl-javap-app.check index 490860585c..eb3718f44b 100644 --- a/test/files/run/repl-javap-app.check +++ b/test/files/run/repl-javap-app.check @@ -1,4 +1,5 @@ #partest java6 +Welcome to Scala Type in expressions to have them evaluated. Type :help for more information. @@ -6,16 +7,17 @@ scala> :javap -app MyApp$ public final void delayedEndpoint$MyApp$1(); Code: Stack=2, Locals=1, Args_size=1 - 0: getstatic #61; //Field scala/Console$.MODULE$:Lscala/Console$; - 3: ldc #63; //String Hello, delayed world. - 5: invokevirtual #67; //Method scala/Console$.println:(Ljava/lang/Object;)V + 0: getstatic #XX; //Field scala/Console$.MODULE$:Lscala/Console$; + 3: ldc #XX; //String Hello, delayed world. + 5: invokevirtual #XX; //Method scala/Console$.println:(Ljava/lang/Object;)V 8: return LocalVariableTable: Start Length Slot Name Signature 0 9 0 this LMyApp$; -scala> -#partest !java6 +scala> :quit +#partest java7 +Welcome to Scala Type in expressions to have them evaluated. Type :help for more information. @@ -24,9 +26,9 @@ scala> :javap -app MyApp$ flags: ACC_PUBLIC, ACC_FINAL Code: stack=2, locals=1, args_size=1 - 0: getstatic #61 // Field scala/Console$.MODULE$:Lscala/Console$; - 3: ldc #63 // String Hello, delayed world. - 5: invokevirtual #67 // Method scala/Console$.println:(Ljava/lang/Object;)V + 0: getstatic #XX // Field scala/Console$.MODULE$:Lscala/Console$; + 3: ldc #XX // String Hello, delayed world. + 5: invokevirtual #XX // Method scala/Console$.println:(Ljava/lang/Object;)V 8: return LocalVariableTable: Start Length Slot Name Signature @@ -35,4 +37,27 @@ scala> :javap -app MyApp$ line 5: 0 } -scala> +scala> :quit +#partest java8 +Welcome to Scala +Type in expressions to have them evaluated. +Type :help for more information. + +scala> :javap -app MyApp$ + public final void delayedEndpoint$MyApp$1(); + descriptor: ()V + flags: ACC_PUBLIC, ACC_FINAL + Code: + stack=2, locals=1, args_size=1 + 0: getstatic #XX // Field scala/Console$.MODULE$:Lscala/Console$; + 3: ldc #XX // String Hello, delayed world. + 5: invokevirtual #XX // Method scala/Console$.println:(Ljava/lang/Object;)V + 8: return + LocalVariableTable: + Start Length Slot Name Signature + 0 9 0 this LMyApp$; + LineNumberTable: + line 5: 0 +} + +scala> :quit diff --git a/test/files/run/repl-javap-app.scala b/test/files/run/repl-javap-app.scala index be04920be1..ad6076c2d5 100644 --- a/test/files/run/repl-javap-app.scala +++ b/test/files/run/repl-javap-app.scala @@ -7,4 +7,15 @@ object MyApp extends App { object Test extends ReplTest { def code = ":javap -app MyApp$" + + override def welcoming = true + + // The constant pool indices are not the same for GenASM / GenBCode, so + // replacing the exact numbers by XX. + lazy val hasConstantPoolRef = """(.*)(#\d\d)(.*)""".r + + override def normalize(s: String) = s match { + case hasConstantPoolRef(start, ref, end) => start + "#XX" + end + case _ => super.normalize(s) + } } diff --git a/test/files/run/repl-javap-lambdas.scala b/test/files/run/repl-javap-lambdas.scala new file mode 100644 index 0000000000..76a6ec8450 --- /dev/null +++ b/test/files/run/repl-javap-lambdas.scala @@ -0,0 +1,23 @@ +import scala.tools.partest.JavapTest +import scala.tools.nsc.Settings + +// see repl-javap-memfun.java for the complementary version +object Test extends JavapTest { + override def transformSettings(s: Settings) = { s.Ydelambdafy.value = "method" ; s } + def code = """ + |object Betty { + | List(1,2,3) count (_ % 2 != 0) + | def f = List(1,2,3) filter ((x: Any) => true) map (x => "m1") + | def g = List(1,2,3) filter ((x: Any) => true) map (x => "m1") map (x => "m2") + |} + |:javap -fun Betty#g + """.stripMargin + + // three anonfuns of Betty#g + override def yah(res: Seq[String]) = { + import PartialFunction.{ cond => when } + val r = """.*final .* .*\$anonfun\$\d+\(.*""".r + def filtered = res filter (when(_) { case r(_*) => true }) + 3 == filtered.size + } +} diff --git a/test/files/run/repl-javap-memfun.scala b/test/files/run/repl-javap-memfun.scala index d2b4243c8b..d10ebcb399 100644 --- a/test/files/run/repl-javap-memfun.scala +++ b/test/files/run/repl-javap-memfun.scala @@ -1,6 +1,10 @@ import scala.tools.partest.JavapTest +import scala.tools.nsc.Settings +// see repl-javap-lambdas.scala for the complementary version object Test extends JavapTest { + // asserting the default + override def transformSettings(s: Settings) = { s.Ydelambdafy.value = "inline" ; s } def code = """ |object Betty { | List(1,2,3) count (_ % 2 != 0) diff --git a/test/files/run/repl-javap-outdir-funs.flags b/test/files/run/repl-javap-outdir-funs.flags new file mode 100644 index 0000000000..ac96850b69 --- /dev/null +++ b/test/files/run/repl-javap-outdir-funs.flags @@ -0,0 +1 @@ +-Ydelambdafy:inline
\ No newline at end of file diff --git a/test/files/run/repl-javap-outdir-funs/run-repl_7.scala b/test/files/run/repl-javap-outdir-funs/run-repl_7.scala index 6c6fe2d515..af9651a8a3 100644 --- a/test/files/run/repl-javap-outdir-funs/run-repl_7.scala +++ b/test/files/run/repl-javap-outdir-funs/run-repl_7.scala @@ -1,6 +1,8 @@ import scala.tools.partest.JavapTest object Test extends JavapTest { + // note the '-fun': it makes :javap search for some anonfun. + // for that reason, this test has a flags file that forces delambdafy:inline (doesn't allow :method) def code = """ |:javap -fun disktest/Foo.class """.stripMargin @@ -11,7 +13,8 @@ object Test extends JavapTest { if (scala.tools.partest.utils.Properties.isAvian) true else { - def filtered = res filter (_ contains "public final class disktest.Foo") + val r = "public final class disktest.Foo.*extends scala.runtime.AbstractFunction1".r + def filtered = res filter (r.findFirstIn(_).nonEmpty) 1 == filtered.size } } diff --git a/test/files/run/repl-out-dir.check b/test/files/run/repl-out-dir.check index 3e51c63155..c354492898 100644 --- a/test/files/run/repl-out-dir.check +++ b/test/files/run/repl-out-dir.check @@ -46,4 +46,4 @@ repl-out-dir-run.obj Test$.class Test.class -scala> +scala> :quit diff --git a/test/files/run/repl-parens.check b/test/files/run/repl-parens.check index 15f4b4524a..74d15ff93c 100644 --- a/test/files/run/repl-parens.check +++ b/test/files/run/repl-parens.check @@ -81,4 +81,4 @@ scala> scala> List(1) ++ List('a') res16: List[AnyVal] = List(1, a) -scala> +scala> :quit diff --git a/test/files/run/repl-paste-2.check b/test/files/run/repl-paste-2.check index ab3809a2e0..6ea8e2f419 100644 --- a/test/files/run/repl-paste-2.check +++ b/test/files/run/repl-paste-2.check @@ -58,4 +58,4 @@ scala> x.length + res5 res3: Int = 129 -scala> +scala> :quit diff --git a/test/files/run/repl-paste-3.check b/test/files/run/repl-paste-3.check index 8fae61792e..23e402852f 100644 --- a/test/files/run/repl-paste-3.check +++ b/test/files/run/repl-paste-3.check @@ -7,4 +7,4 @@ scala> println(3) scala> List(1,2) res1: List[Int] = List(1, 2) -scala> +scala> :quit diff --git a/test/files/run/repl-paste-4.scala b/test/files/run/repl-paste-4.scala index 0060dc1ff6..cb0a6aa768 100644 --- a/test/files/run/repl-paste-4.scala +++ b/test/files/run/repl-paste-4.scala @@ -14,7 +14,7 @@ s"""|Type in expressions to have them evaluated. |scala> Foo(new Foo) |res0: Int = 7 | - |scala> """ + |scala> :quit""" def pastie = testPath changeExtension "pastie" } diff --git a/test/files/run/repl-paste-raw.scala b/test/files/run/repl-paste-raw.scala index 2953796f99..3b41254e96 100644 --- a/test/files/run/repl-paste-raw.scala +++ b/test/files/run/repl-paste-raw.scala @@ -15,6 +15,6 @@ s"""|Type in expressions to have them evaluated. |scala> favoriteThing.hasString |res0: Boolean = true | - |scala> """ + |scala> :quit""" def pastie = testPath changeExtension "pastie" } diff --git a/test/files/run/repl-paste.check b/test/files/run/repl-paste.check index 97f177ddc4..171447214f 100644 --- a/test/files/run/repl-paste.check +++ b/test/files/run/repl-paste.check @@ -23,4 +23,4 @@ defined class Dingus defined object Dingus x: Int = 110 -scala> +scala> :quit diff --git a/test/files/run/repl-power.check b/test/files/run/repl-power.check index e56901e0f2..e2318c93f2 100644 --- a/test/files/run/repl-power.check +++ b/test/files/run/repl-power.check @@ -11,11 +11,11 @@ scala> :power scala> // guarding against "error: reference to global is ambiguous" scala> global.emptyValDef // "it is imported twice in the same scope by ..." -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res0: $r.global.noSelfType.type = private val _ = _ scala> val tp = ArrayClass[scala.util.Random] // magic with tags -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details tp: $r.global.Type = Array[scala.util.Random] scala> tp.memberType(Array_apply) // evidence @@ -27,4 +27,4 @@ m: $r.treedsl.global.Literal = 10 scala> typed(m).tpe // typed is in scope res2: $r.treedsl.global.Type = Int(10) -scala> +scala> :quit diff --git a/test/files/run/repl-reset.check b/test/files/run/repl-reset.check index ed95c7b8ff..cd7893bbc3 100644 --- a/test/files/run/repl-reset.check +++ b/test/files/run/repl-reset.check @@ -54,4 +54,4 @@ defined class BippyBungus scala> { new BippyBungus ; x1 } res2: Int = 4 -scala> +scala> :quit diff --git a/test/files/run/repl-save.scala b/test/files/run/repl-save.scala index 4539790b1a..c98e6aebc3 100644 --- a/test/files/run/repl-save.scala +++ b/test/files/run/repl-save.scala @@ -16,7 +16,7 @@ s"""|Type in expressions to have them evaluated. | |scala> :save $saveto | - |scala> """ + |scala> :quit""" def saveto = testOutput / "session.repl" override def show() = { super.show() diff --git a/test/files/run/repl-term-macros.check b/test/files/run/repl-term-macros.check index 3580bfe1f1..2cd0b93cd0 100644 --- a/test/files/run/repl-term-macros.check +++ b/test/files/run/repl-term-macros.check @@ -37,4 +37,4 @@ defined term macro foo3: (x: Int)(y: Int)Unit scala> foo3(2)(3) -scala> +scala> :quit diff --git a/test/files/run/repl-transcript.check b/test/files/run/repl-transcript.check index 49891af900..b0f106387b 100644 --- a/test/files/run/repl-transcript.check +++ b/test/files/run/repl-transcript.check @@ -35,4 +35,4 @@ scala> res6.sum + res5 res0: Int = 5273 -scala> +scala> :quit diff --git a/test/files/run/repl-trim-stack-trace.scala b/test/files/run/repl-trim-stack-trace.scala index 483659146a..a53ce3b3e4 100644 --- a/test/files/run/repl-trim-stack-trace.scala +++ b/test/files/run/repl-trim-stack-trace.scala @@ -32,7 +32,7 @@ java.lang.Exception at .f(<console>:7) ... 69 elided -scala> """ +scala> :quit""" // normalize the "elided" lines because the frame count depends on test context lazy val elided = """(\s+\.{3} )\d+( elided)""".r diff --git a/test/files/run/repl-type-verbose.check b/test/files/run/repl-type-verbose.check index e37754a060..6f6b47b86d 100644 --- a/test/files/run/repl-type-verbose.check +++ b/test/files/run/repl-type-verbose.check @@ -187,4 +187,4 @@ PolyType( ) ) -scala> +scala> :quit diff --git a/test/files/run/richs.check b/test/files/run/richs.check index 02a98b376d..cf265ae007 100644 --- a/test/files/run/richs.check +++ b/test/files/run/richs.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details RichCharTest1: true diff --git a/test/files/run/sammy_repeated.check b/test/files/run/sammy_repeated.check new file mode 100644 index 0000000000..1cff0f067c --- /dev/null +++ b/test/files/run/sammy_repeated.check @@ -0,0 +1 @@ +WrappedArray(1) diff --git a/test/files/run/t5532.flags b/test/files/run/sammy_repeated.flags index e1b37447c9..e1b37447c9 100644 --- a/test/files/run/t5532.flags +++ b/test/files/run/sammy_repeated.flags diff --git a/test/files/run/sammy_repeated.scala b/test/files/run/sammy_repeated.scala new file mode 100644 index 0000000000..c24dc41909 --- /dev/null +++ b/test/files/run/sammy_repeated.scala @@ -0,0 +1,8 @@ +trait RepeatedSink { def accept(a: Any*): Unit } + +object Test { + def main(args: Array[String]): Unit = { + val f: RepeatedSink = (a) => println(a) + f.accept(1) + } +}
\ No newline at end of file diff --git a/test/files/run/search.check b/test/files/run/search.check index a885696509..e0c55043e3 100644 --- a/test/files/run/search.check +++ b/test/files/run/search.check @@ -1,6 +1,6 @@ Found(2) Found(4) -InsertionPoint(9) +InsertionPoint(10) Found(2) Found(4) -InsertionPoint(9) +InsertionPoint(10) diff --git a/test/files/run/settings-parse.scala b/test/files/run/settings-parse.scala index 2754feb972..8d83caf68f 100644 --- a/test/files/run/settings-parse.scala +++ b/test/files/run/settings-parse.scala @@ -3,9 +3,8 @@ import scala.language.postfixOps import scala.tools.nsc._ object Test { - val tokens = List("", "-deprecation", "foo.scala") - val subsets = tokens.toSet.subsets.toList - val permutations0 = subsets.flatMap(_.toList.permutations).distinct + val tokens = "" :: "-deprecation" :: "foo.scala" :: Nil + val permutations0 = tokens.toSet.subsets.flatMap(_.toList.permutations).toList.distinct def runWithCp(cp: String) = { val permutations = permutations0 flatMap ("-cp CPTOKEN" :: _ permutations) diff --git a/test/files/run/stringinterpolation_macro-run.check b/test/files/run/stringinterpolation_macro-run.check index ead61e76ac..c7f46bac87 100644 --- a/test/files/run/stringinterpolation_macro-run.check +++ b/test/files/run/stringinterpolation_macro-run.check @@ -63,5 +63,9 @@ She is 4 feet tall. 05/26/12 05/26/12 % + mind +------ +matter + 7 7 9 7 9 9 diff --git a/test/files/run/stringinterpolation_macro-run.scala b/test/files/run/stringinterpolation_macro-run.scala index ff779dd1d3..ae7c0e5d7a 100644 --- a/test/files/run/stringinterpolation_macro-run.scala +++ b/test/files/run/stringinterpolation_macro-run.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with */ object Test extends App { @@ -115,6 +115,7 @@ println(f"""${"1234"}%TD""") // literals and arg indexes println(f"%%") +println(f" mind%n------%nmatter%n") println(f"${7}%d %<d ${9}%d") println(f"${7}%d %2$$d ${9}%d") diff --git a/test/files/run/synchronized.check b/test/files/run/synchronized.check index 6e99739633..9add05ea0c 100644 --- a/test/files/run/synchronized.check +++ b/test/files/run/synchronized.check @@ -1,4 +1,8 @@ -warning: there were 14 inliner warning(s); re-run with -Yinline-warnings for details +#partest !-Ybackend:GenBCode +warning: there were 14 inliner warnings; re-run with -Yinline-warnings for details +#partest -Ybackend:GenBCode +warning: there were 14 inliner warnings; re-run with -Yopt-warnings for details +#partest .|. c1.f1: OK .|. c1.fi: OK .|... c1.fv: OK diff --git a/test/files/run/t1994.scala b/test/files/run/t1994.scala new file mode 100644 index 0000000000..0b463e3444 --- /dev/null +++ b/test/files/run/t1994.scala @@ -0,0 +1,20 @@ +class A { + protected def x = 0 + protected[A] def y = 0 +} + +class B extends A { + override def x = 1 + def superY = super[A].y + override def y = 1 +} + + +object Test { + def main(args: Array[String]): Unit = { + val b = new B + assert(b.x == 1) + assert(b.y == 1) + assert(b.superY == 0) + } +} diff --git a/test/files/run/t2212.check b/test/files/run/t2212.check index 8ab4d60ab3..1465f1341a 100644 --- a/test/files/run/t2212.check +++ b/test/files/run/t2212.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details LinkedList(1) LinkedList(1) true diff --git a/test/files/run/t2318.scala b/test/files/run/t2318.scala index b638c433f5..4239c017b8 100644 --- a/test/files/run/t2318.scala +++ b/test/files/run/t2318.scala @@ -11,6 +11,7 @@ object Test { case _: java.io.FilePermission => () case x: java.security.SecurityPermission if x.getName contains ".networkaddress." => () // generality ftw case x: java.util.PropertyPermission if x.getName == "sun.net.inetaddr.ttl" => () + case _: java.lang.reflect.ReflectPermission => () // needed for LambdaMetaFactory case _ => super.checkPermission(perm) } } diff --git a/test/files/run/t2866.check b/test/files/run/t2866.check new file mode 100644 index 0000000000..7f52da85fb --- /dev/null +++ b/test/files/run/t2866.check @@ -0,0 +1,3 @@ +t2866.scala:30: warning: imported `one' is permanently hidden by definition of value one + import A.one // warning: imported `one' is permanently hidden by definition of value one. + ^ diff --git a/test/files/run/t2866.scala b/test/files/run/t2866.scala new file mode 100644 index 0000000000..8059107583 --- /dev/null +++ b/test/files/run/t2866.scala @@ -0,0 +1,44 @@ +// for 2.7.x compatibility + +object A { + implicit val one = 1 +} + +object Test extends App { + + locally { + import A._ + locally { + // assert(implicitly[Int] == 1) // error: could not find implicit value for parameter e: Int. + // !!! Why one A.one? + // (I assume you mean: why _not_ A.one? A.one is shadowed by local one. + // but the local one cannot be used yet because it does not have an explicit type. + implicit val one = 2 + assert(implicitly[Int] == 2) + assert(one == 2) + } + } + + locally { + import A._ + implicit val one: Int = 2 + assert(implicitly[Int] == 2) + assert(one == 2) + } + + locally { + import A.one // warning: imported `one' is permanently hidden by definition of value one. + // !!! Really? + //assert(implicitly[Int] == 1) + implicit val one = 2 + assert(implicitly[Int] == 2) // !!! why not 2? + assert(one == 2) + } + + locally { + import A.{one => _, _} + implicit val two = 2 + assert(implicitly[Int] == 2) // not ambiguous in 2.8.0 nor im ambiguous in 2.7.6 + } + +} diff --git a/test/files/run/t3361.check b/test/files/run/t3361.check index c18bdc9aff..5e0a763501 100644 --- a/test/files/run/t3361.check +++ b/test/files/run/t3361.check @@ -1 +1 @@ -warning: there were 16 deprecation warning(s); re-run with -deprecation for details +warning: there were 16 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t3368-b.check b/test/files/run/t3368-b.check new file mode 100644 index 0000000000..4cbe98c577 --- /dev/null +++ b/test/files/run/t3368-b.check @@ -0,0 +1,89 @@ +[[syntax trees at end of parser]] // newSource1.scala +package <empty> { + abstract trait X extends scala.AnyRef { + def $init$() = { + () + }; + def x = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hi & bye")); + $buf.$amp$plus(new _root_.scala.xml.PCData("red & black")); + $buf + } + }; + abstract trait Y extends scala.AnyRef { + def $init$() = { + () + }; + def y = { + { + new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("start")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hi & bye")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "c", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("world")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "d", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("stuff")); + $buf.$amp$plus(new _root_.scala.xml.PCData("red & black")); + $buf + }: _*)) + } + } + }; + abstract trait Z extends scala.AnyRef { + def $init$() = { + () + }; + def d = new _root_.scala.xml.PCData("hello, world"); + def e = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }; + def f = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("x")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }: _*)) + } + }; + def g = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }: _*)) + } + }; + def h = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }: _*)) + } + } + } +} + diff --git a/test/files/run/t3368-b.scala b/test/files/run/t3368-b.scala new file mode 100644 index 0000000000..108cb9a5ee --- /dev/null +++ b/test/files/run/t3368-b.scala @@ -0,0 +1,26 @@ + +import scala.tools.partest.ParserTest + + +object Test extends ParserTest { + + override def code = """ + trait X { + // error: in XML literal: name expected, but char '!' cannot start a name + def x = <![CDATA[hi & bye]]> <![CDATA[red & black]]> + } + trait Y { + def y = <a><b/>start<![CDATA[hi & bye]]><c/>world<d/>stuff<![CDATA[red & black]]></a> + } + trait Z { + def d = <![CDATA[hello, world]]> + def e = <![CDATA[hello, world]]><![CDATA[hello, world]]> // top level not coalesced + def f = <foo>x<![CDATA[hello, world]]></foo> // adjoining text + def g = <foo><![CDATA[hello, world]]></foo> // text node when coalescing + def h = <foo><![CDATA[hello, world]]><![CDATA[hello, world]]></foo> + } + """ + + // not coalescing + override def extraSettings = s"${super.extraSettings} -Xxml:-coalescing" +} diff --git a/test/files/run/t3368-c.check b/test/files/run/t3368-c.check new file mode 100644 index 0000000000..e0c10cc0dd --- /dev/null +++ b/test/files/run/t3368-c.check @@ -0,0 +1,85 @@ +[[syntax trees at end of parser]] // newSource1.scala +package <empty> { + abstract trait X extends scala.AnyRef { + def $init$() = { + () + }; + def x = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hi & bye")); + $buf.$amp$plus(new _root_.scala.xml.Text("red & black")); + $buf + } + }; + abstract trait Y extends scala.AnyRef { + def $init$() = { + () + }; + def y = { + { + new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("starthi & bye")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "c", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("world")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "d", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("stuffred & black")); + $buf + }: _*)) + } + } + }; + abstract trait Z extends scala.AnyRef { + def $init$() = { + () + }; + def d = new _root_.scala.xml.Text("hello, world"); + def e = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, world")); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, world")); + $buf + }; + def f = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("xhello, world")); + $buf + }: _*)) + } + }; + def g = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, world")); + $buf + }: _*)) + } + }; + def h = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, worldhello, world")); + $buf + }: _*)) + } + } + } +} + diff --git a/test/files/run/t3368-c.scala b/test/files/run/t3368-c.scala new file mode 100644 index 0000000000..5121794463 --- /dev/null +++ b/test/files/run/t3368-c.scala @@ -0,0 +1,26 @@ + +import scala.tools.partest.ParserTest + + +object Test extends ParserTest { + + override def code = """ + trait X { + // error: in XML literal: name expected, but char '!' cannot start a name + def x = <![CDATA[hi & bye]]> <![CDATA[red & black]]> + } + trait Y { + def y = <a><b/>start<![CDATA[hi & bye]]><c/>world<d/>stuff<![CDATA[red & black]]></a> + } + trait Z { + def d = <![CDATA[hello, world]]> + def e = <![CDATA[hello, world]]><![CDATA[hello, world]]> // top level not coalesced + def f = <foo>x<![CDATA[hello, world]]></foo> // adjoining text + def g = <foo><![CDATA[hello, world]]></foo> // text node when coalescing + def h = <foo><![CDATA[hello, world]]><![CDATA[hello, world]]></foo> + } + """ + + // default coalescing behavior, whatever that is today. + //override def extraSettings = s"${super.extraSettings} -Xxml:coalescing" +} diff --git a/test/files/run/t3368-d.check b/test/files/run/t3368-d.check new file mode 100644 index 0000000000..4cbe98c577 --- /dev/null +++ b/test/files/run/t3368-d.check @@ -0,0 +1,89 @@ +[[syntax trees at end of parser]] // newSource1.scala +package <empty> { + abstract trait X extends scala.AnyRef { + def $init$() = { + () + }; + def x = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hi & bye")); + $buf.$amp$plus(new _root_.scala.xml.PCData("red & black")); + $buf + } + }; + abstract trait Y extends scala.AnyRef { + def $init$() = { + () + }; + def y = { + { + new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("start")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hi & bye")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "c", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("world")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "d", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("stuff")); + $buf.$amp$plus(new _root_.scala.xml.PCData("red & black")); + $buf + }: _*)) + } + } + }; + abstract trait Z extends scala.AnyRef { + def $init$() = { + () + }; + def d = new _root_.scala.xml.PCData("hello, world"); + def e = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }; + def f = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("x")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }: _*)) + } + }; + def g = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }: _*)) + } + }; + def h = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf.$amp$plus(new _root_.scala.xml.PCData("hello, world")); + $buf + }: _*)) + } + } + } +} + diff --git a/test/files/run/t3368-d.scala b/test/files/run/t3368-d.scala new file mode 100644 index 0000000000..5777c1a81e --- /dev/null +++ b/test/files/run/t3368-d.scala @@ -0,0 +1,26 @@ + +import scala.tools.partest.ParserTest + + +object Test extends ParserTest { + + override def code = """ + trait X { + // error: in XML literal: name expected, but char '!' cannot start a name + def x = <![CDATA[hi & bye]]> <![CDATA[red & black]]> + } + trait Y { + def y = <a><b/>start<![CDATA[hi & bye]]><c/>world<d/>stuff<![CDATA[red & black]]></a> + } + trait Z { + def d = <![CDATA[hello, world]]> + def e = <![CDATA[hello, world]]><![CDATA[hello, world]]> // top level not coalesced + def f = <foo>x<![CDATA[hello, world]]></foo> // adjoining text + def g = <foo><![CDATA[hello, world]]></foo> // text node when coalescing + def h = <foo><![CDATA[hello, world]]><![CDATA[hello, world]]></foo> + } + """ + + // default under 2.12 is not coalescing + override def extraSettings = s"${super.extraSettings} -Xsource:212" +} diff --git a/test/files/run/t3368.check b/test/files/run/t3368.check new file mode 100644 index 0000000000..e0c10cc0dd --- /dev/null +++ b/test/files/run/t3368.check @@ -0,0 +1,85 @@ +[[syntax trees at end of parser]] // newSource1.scala +package <empty> { + abstract trait X extends scala.AnyRef { + def $init$() = { + () + }; + def x = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hi & bye")); + $buf.$amp$plus(new _root_.scala.xml.Text("red & black")); + $buf + } + }; + abstract trait Y extends scala.AnyRef { + def $init$() = { + () + }; + def y = { + { + new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("starthi & bye")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "c", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("world")); + $buf.$amp$plus({ + { + new _root_.scala.xml.Elem(null, "d", _root_.scala.xml.Null, $scope, true) + } + }); + $buf.$amp$plus(new _root_.scala.xml.Text("stuffred & black")); + $buf + }: _*)) + } + } + }; + abstract trait Z extends scala.AnyRef { + def $init$() = { + () + }; + def d = new _root_.scala.xml.Text("hello, world"); + def e = { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, world")); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, world")); + $buf + }; + def f = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("xhello, world")); + $buf + }: _*)) + } + }; + def g = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, world")); + $buf + }: _*)) + } + }; + def h = { + { + new _root_.scala.xml.Elem(null, "foo", _root_.scala.xml.Null, $scope, false, ({ + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Text("hello, worldhello, world")); + $buf + }: _*)) + } + } + } +} + diff --git a/test/files/run/t3368.scala b/test/files/run/t3368.scala new file mode 100644 index 0000000000..284fed0784 --- /dev/null +++ b/test/files/run/t3368.scala @@ -0,0 +1,26 @@ + +import scala.tools.partest.ParserTest + + +object Test extends ParserTest { + + override def code = """ + trait X { + // error: in XML literal: name expected, but char '!' cannot start a name + def x = <![CDATA[hi & bye]]> <![CDATA[red & black]]> + } + trait Y { + def y = <a><b/>start<![CDATA[hi & bye]]><c/>world<d/>stuff<![CDATA[red & black]]></a> + } + trait Z { + def d = <![CDATA[hello, world]]> + def e = <![CDATA[hello, world]]><![CDATA[hello, world]]> // top level not coalesced + def f = <foo>x<![CDATA[hello, world]]></foo> // adjoining text + def g = <foo><![CDATA[hello, world]]></foo> // text node when coalescing + def h = <foo><![CDATA[hello, world]]><![CDATA[hello, world]]></foo> + } + """ + + // coalescing + override def extraSettings = s"${super.extraSettings} -Xxml:coalescing" +} diff --git a/test/files/run/t3376.check b/test/files/run/t3376.check index cc6949d326..b8fd2843f6 100644 --- a/test/files/run/t3376.check +++ b/test/files/run/t3376.check @@ -13,4 +13,4 @@ m2: M[Float] = mmm scala> val m3 = new M[String]() m3: M[String] = mmm -scala> +scala> :quit diff --git a/test/files/run/t3516.check b/test/files/run/t3516.check deleted file mode 100644 index d0d10d82fa..0000000000 --- a/test/files/run/t3516.check +++ /dev/null @@ -1,3 +0,0 @@ -1 -1 -21 diff --git a/test/files/run/t3516.scala b/test/files/run/t3516.scala deleted file mode 100644 index aa302ce85a..0000000000 --- a/test/files/run/t3516.scala +++ /dev/null @@ -1,13 +0,0 @@ -object Test { - def mkIterator = (1 to 5).iterator map (x => { println(x) ; x }) - def mkInfinite = Iterator continually { println(1) ; 1 } - - def main(args: Array[String]): Unit = { - // Stream is strict in its head so we should see 1 from each of them. - val s1 = mkIterator.toStream - val s2 = mkInfinite.toStream - // back and forth without slipping into nontermination. - println((Stream from 1).toIterator.drop(10).toStream.drop(10).toIterator.next) - () - } -} diff --git a/test/files/run/t3569.scala b/test/files/run/t3569.scala index 91d437e0e3..eb3b424439 100644 --- a/test/files/run/t3569.scala +++ b/test/files/run/t3569.scala @@ -26,7 +26,8 @@ object Test { s.x += 1 println(s.x) - (classOf[X].getDeclaredFields map ("" + _)).sorted foreach println + // under -Xcheckinit there's an additional $init$ field + (classOf[X].getDeclaredFields map ("" + _)).sorted.filter(_ != "private volatile byte Test$X.bitmap$init$0") foreach println (classOf[Y].getDeclaredFields map ("" + _)).sorted foreach println } } diff --git a/test/files/run/t3888.check b/test/files/run/t3888.check index 844ca54682..df1629dd7e 100644 --- a/test/files/run/t3888.check +++ b/test/files/run/t3888.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details diff --git a/test/files/run/t3970.check b/test/files/run/t3970.check index bd89fff9d9..0683a6c1a6 100644 --- a/test/files/run/t3970.check +++ b/test/files/run/t3970.check @@ -1 +1 @@ -warning: there were 5 deprecation warning(s); re-run with -deprecation for details +warning: there were 5 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t3996.check b/test/files/run/t3996.check index a92ddc0e51..a9ecc29fea 100644 --- a/test/files/run/t3996.check +++ b/test/files/run/t3996.check @@ -1 +1 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t4025.check b/test/files/run/t4025.check index 2d4f644c5a..e8c6851236 100644 --- a/test/files/run/t4025.check +++ b/test/files/run/t4025.check @@ -14,4 +14,4 @@ scala> scala> def f(c: Any) = c match { case Red(_) => () } f: (c: Any)Unit -scala> +scala> :quit diff --git a/test/files/run/t4080.check b/test/files/run/t4080.check index 1953a68ad3..462e925b76 100644 --- a/test/files/run/t4080.check +++ b/test/files/run/t4080.check @@ -1,2 +1,2 @@ -warning: there were 3 deprecation warning(s); re-run with -deprecation for details +warning: there were three deprecation warnings; re-run with -deprecation for details LinkedList(1, 0, 2, 3) diff --git a/test/files/run/t4172.check b/test/files/run/t4172.check index d94638d27e..315c1c9dbd 100644 --- a/test/files/run/t4172.check +++ b/test/files/run/t4172.check @@ -2,7 +2,7 @@ Type in expressions to have them evaluated. Type :help for more information. scala> val c = { class C { override def toString = "C" }; ((new C, new C { def f = 2 })) } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details c: (C, C{def f: Int}) forSome { type C <: AnyRef } = (C,C) -scala> +scala> :quit diff --git a/test/files/run/t4216.check b/test/files/run/t4216.check index 091e55a0c7..e4610e87d3 100644 --- a/test/files/run/t4216.check +++ b/test/files/run/t4216.check @@ -34,4 +34,4 @@ res4: java.util.List[V] = [V@0] scala> o(new V(0)) res5: java.util.List[Any] = [V@0] -scala> +scala> :quit diff --git a/test/files/run/t4285.check b/test/files/run/t4285.check index 314c8e5a35..b952cb8e1b 100644 --- a/test/files/run/t4285.check +++ b/test/files/run/t4285.check @@ -10,4 +10,4 @@ y: scala.collection.mutable.WrappedArray[Int] = WrappedArray(2, 4, 6, 8, 10, 12, scala> println(y.sum) 56 -scala> +scala> :quit diff --git a/test/files/run/t4396.check b/test/files/run/t4396.check index a75e1f257f..d38fb7fae7 100644 --- a/test/files/run/t4396.check +++ b/test/files/run/t4396.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details hallo constructor out:22 diff --git a/test/files/run/t4461.check b/test/files/run/t4461.check index 9488669324..346993af6f 100644 --- a/test/files/run/t4461.check +++ b/test/files/run/t4461.check @@ -1,4 +1,4 @@ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details Include(End,1) Include(End,2) Include(End,3) diff --git a/test/files/run/t4542.check b/test/files/run/t4542.check index a53f31a3c7..f7716dc2f0 100644 --- a/test/files/run/t4542.check +++ b/test/files/run/t4542.check @@ -12,4 +12,4 @@ scala> val f = new Foo ^ f: Foo = Bippy -scala> +scala> :quit diff --git a/test/files/run/t4594-repl-settings.scala b/test/files/run/t4594-repl-settings.scala index d2335460e5..db5dc19866 100644 --- a/test/files/run/t4594-repl-settings.scala +++ b/test/files/run/t4594-repl-settings.scala @@ -11,10 +11,10 @@ object Test extends SessionTest { |depp: String | |scala> def a = depp - |warning: there were 1 deprecation warning(s); re-run with -deprecation for details + |warning: there was one deprecation warning; re-run with -deprecation for details |a: String | - |scala> :settings +deprecation + |scala> :settings -deprecation | |scala> def b = depp |<console>:8: warning: method depp is deprecated: Please don't do that. @@ -22,5 +22,5 @@ object Test extends SessionTest { | ^ |b: String | - |scala> """ + |scala> :quit""" } diff --git a/test/files/run/t4671.check b/test/files/run/t4671.check index 0c36083759..1640dac8e4 100644 --- a/test/files/run/t4671.check +++ b/test/files/run/t4671.check @@ -43,4 +43,4 @@ println(s.mkString("")) } -scala> +scala> :quit diff --git a/test/files/run/t4680.check b/test/files/run/t4680.check index 512bfd4b54..21a1e0cd15 100644 --- a/test/files/run/t4680.check +++ b/test/files/run/t4680.check @@ -4,7 +4,7 @@ t4680.scala:51: warning: a pure expression does nothing in statement position; y t4680.scala:69: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses new { val x = 5 } with E() { 5 } ^ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details // new C { } diff --git a/test/files/run/t4710.check b/test/files/run/t4710.check index f2335d1bdd..0dd49dfbd3 100644 --- a/test/files/run/t4710.check +++ b/test/files/run/t4710.check @@ -2,7 +2,7 @@ Type in expressions to have them evaluated. Type :help for more information. scala> def method : String = { implicit def f(s: Symbol) = "" ; 'symbol } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details method: String -scala> +scala> :quit diff --git a/test/files/run/t4788-separate-compilation.check b/test/files/run/t4788-separate-compilation.check new file mode 100644 index 0000000000..172ad90102 --- /dev/null +++ b/test/files/run/t4788-separate-compilation.check @@ -0,0 +1,5 @@ +Some(@Ljava/lang/Deprecated;()) +None +None +Some(@LCAnnotation;() // invisible) +Some(@LRAnnotation;()) diff --git a/test/files/run/t4788-separate-compilation/CAnnotation_1.java b/test/files/run/t4788-separate-compilation/CAnnotation_1.java new file mode 100644 index 0000000000..7120218d62 --- /dev/null +++ b/test/files/run/t4788-separate-compilation/CAnnotation_1.java @@ -0,0 +1,5 @@ +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.CLASS; + +@Retention(value=CLASS) +@interface CAnnotation {} diff --git a/test/files/run/t4788-separate-compilation/C_1.scala b/test/files/run/t4788-separate-compilation/C_1.scala new file mode 100644 index 0000000000..aba9b595e4 --- /dev/null +++ b/test/files/run/t4788-separate-compilation/C_1.scala @@ -0,0 +1,2 @@ +@CAnnotation +class C diff --git a/test/files/run/t4788-separate-compilation/D_1.scala b/test/files/run/t4788-separate-compilation/D_1.scala new file mode 100644 index 0000000000..c2479fba86 --- /dev/null +++ b/test/files/run/t4788-separate-compilation/D_1.scala @@ -0,0 +1,5 @@ +@Deprecated +class DJava + +@deprecated("", "") +class DScala diff --git a/test/files/run/t4788-separate-compilation/RAnnotation_1.java b/test/files/run/t4788-separate-compilation/RAnnotation_1.java new file mode 100644 index 0000000000..f24cf66f7b --- /dev/null +++ b/test/files/run/t4788-separate-compilation/RAnnotation_1.java @@ -0,0 +1,5 @@ +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +@Retention(value=RUNTIME) +@interface RAnnotation {} diff --git a/test/files/run/t4788-separate-compilation/R_1.scala b/test/files/run/t4788-separate-compilation/R_1.scala new file mode 100644 index 0000000000..ab0cd065d9 --- /dev/null +++ b/test/files/run/t4788-separate-compilation/R_1.scala @@ -0,0 +1,2 @@ +@RAnnotation +class R diff --git a/test/files/run/t4788-separate-compilation/SAnnotation_1.java b/test/files/run/t4788-separate-compilation/SAnnotation_1.java new file mode 100644 index 0000000000..471f27d82a --- /dev/null +++ b/test/files/run/t4788-separate-compilation/SAnnotation_1.java @@ -0,0 +1,5 @@ +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.SOURCE; + +@Retention(value=SOURCE) +@interface SAnnotation {} diff --git a/test/files/run/t4788-separate-compilation/S_1.scala b/test/files/run/t4788-separate-compilation/S_1.scala new file mode 100644 index 0000000000..f8756d9bc8 --- /dev/null +++ b/test/files/run/t4788-separate-compilation/S_1.scala @@ -0,0 +1,2 @@ +@SAnnotation +class S diff --git a/test/files/run/t4788-separate-compilation/Test_2.scala b/test/files/run/t4788-separate-compilation/Test_2.scala new file mode 100644 index 0000000000..cbbb5ff386 --- /dev/null +++ b/test/files/run/t4788-separate-compilation/Test_2.scala @@ -0,0 +1,35 @@ +import java.io.PrintWriter; + +import scala.tools.partest.BytecodeTest +import scala.tools.asm.util._ +import scala.tools.nsc.util.stringFromWriter + +object Test extends BytecodeTest { + def annotationsForClass(className: String): Option[String] = { + val classNode = loadClassNode(className, skipDebugInfo = false) + val textifier = new Textifier + classNode.accept(new TraceClassVisitor(null, textifier, null)) + + val classString = stringFromWriter(w => textifier.print(w)) + classString + .split('\n') + .filterNot(_.contains("@Lscala/reflect/ScalaSignature")) + .find(_.contains("@L")) + .map(_.trim) + } + + def show { + // It seems like @java.lang.Deprecated shows up in both the + // Deprecated attribute and RuntimeVisibleAnnotation attribute, + // while @scala.deprecated only shows up in the Deprecated attribute. + // The check file just documents status quo, not sure if Scala + // should brought in line with Java or not... + // See the commit message and SI-8883 for more info. + println(annotationsForClass("DJava")) + println(annotationsForClass("DScala")) + + println(annotationsForClass("S")) + println(annotationsForClass("C")) + println(annotationsForClass("R")) + } +} diff --git a/test/files/run/t4788.check b/test/files/run/t4788.check new file mode 100644 index 0000000000..172ad90102 --- /dev/null +++ b/test/files/run/t4788.check @@ -0,0 +1,5 @@ +Some(@Ljava/lang/Deprecated;()) +None +None +Some(@LCAnnotation;() // invisible) +Some(@LRAnnotation;()) diff --git a/test/files/run/t4788/C.scala b/test/files/run/t4788/C.scala new file mode 100644 index 0000000000..aba9b595e4 --- /dev/null +++ b/test/files/run/t4788/C.scala @@ -0,0 +1,2 @@ +@CAnnotation +class C diff --git a/test/files/run/t4788/CAnnotation.java b/test/files/run/t4788/CAnnotation.java new file mode 100644 index 0000000000..7120218d62 --- /dev/null +++ b/test/files/run/t4788/CAnnotation.java @@ -0,0 +1,5 @@ +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.CLASS; + +@Retention(value=CLASS) +@interface CAnnotation {} diff --git a/test/files/run/t4788/D.scala b/test/files/run/t4788/D.scala new file mode 100644 index 0000000000..c2479fba86 --- /dev/null +++ b/test/files/run/t4788/D.scala @@ -0,0 +1,5 @@ +@Deprecated +class DJava + +@deprecated("", "") +class DScala diff --git a/test/files/run/t4788/R.scala b/test/files/run/t4788/R.scala new file mode 100644 index 0000000000..ab0cd065d9 --- /dev/null +++ b/test/files/run/t4788/R.scala @@ -0,0 +1,2 @@ +@RAnnotation +class R diff --git a/test/files/run/t4788/RAnnotation.java b/test/files/run/t4788/RAnnotation.java new file mode 100644 index 0000000000..f24cf66f7b --- /dev/null +++ b/test/files/run/t4788/RAnnotation.java @@ -0,0 +1,5 @@ +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +@Retention(value=RUNTIME) +@interface RAnnotation {} diff --git a/test/files/run/t4788/S.scala b/test/files/run/t4788/S.scala new file mode 100644 index 0000000000..f8756d9bc8 --- /dev/null +++ b/test/files/run/t4788/S.scala @@ -0,0 +1,2 @@ +@SAnnotation +class S diff --git a/test/files/run/t4788/SAnnotation.java b/test/files/run/t4788/SAnnotation.java new file mode 100644 index 0000000000..471f27d82a --- /dev/null +++ b/test/files/run/t4788/SAnnotation.java @@ -0,0 +1,5 @@ +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.SOURCE; + +@Retention(value=SOURCE) +@interface SAnnotation {} diff --git a/test/files/run/t4788/Test.scala b/test/files/run/t4788/Test.scala new file mode 100644 index 0000000000..cbbb5ff386 --- /dev/null +++ b/test/files/run/t4788/Test.scala @@ -0,0 +1,35 @@ +import java.io.PrintWriter; + +import scala.tools.partest.BytecodeTest +import scala.tools.asm.util._ +import scala.tools.nsc.util.stringFromWriter + +object Test extends BytecodeTest { + def annotationsForClass(className: String): Option[String] = { + val classNode = loadClassNode(className, skipDebugInfo = false) + val textifier = new Textifier + classNode.accept(new TraceClassVisitor(null, textifier, null)) + + val classString = stringFromWriter(w => textifier.print(w)) + classString + .split('\n') + .filterNot(_.contains("@Lscala/reflect/ScalaSignature")) + .find(_.contains("@L")) + .map(_.trim) + } + + def show { + // It seems like @java.lang.Deprecated shows up in both the + // Deprecated attribute and RuntimeVisibleAnnotation attribute, + // while @scala.deprecated only shows up in the Deprecated attribute. + // The check file just documents status quo, not sure if Scala + // should brought in line with Java or not... + // See the commit message and SI-8883 for more info. + println(annotationsForClass("DJava")) + println(annotationsForClass("DScala")) + + println(annotationsForClass("S")) + println(annotationsForClass("C")) + println(annotationsForClass("R")) + } +} diff --git a/test/files/run/t4813.check b/test/files/run/t4813.check index a92ddc0e51..a9ecc29fea 100644 --- a/test/files/run/t4813.check +++ b/test/files/run/t4813.check @@ -1 +1 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t4950.check b/test/files/run/t4950.check new file mode 100644 index 0000000000..3f3a302b62 --- /dev/null +++ b/test/files/run/t4950.check @@ -0,0 +1,9 @@ +Type in expressions to have them evaluated. +Type :help for more information. + +scala> val 1 = 2 +scala.MatchError: 2 (of class java.lang.Integer) + +scala> val List(1) = List(1) + +scala> :quit diff --git a/test/files/run/t4950.scala b/test/files/run/t4950.scala new file mode 100644 index 0000000000..cef06027bf --- /dev/null +++ b/test/files/run/t4950.scala @@ -0,0 +1,12 @@ +import scala.tools.partest.ReplTest + +object Test extends ReplTest { + // Filter out the abbreviated stacktrace "... X elided" + // because the number seems to differ between versions/platforms/... + override def show = eval() filterNot (_ contains "elided") foreach println + def code = +""" +val 1 = 2 +val List(1) = List(1) +""" +} diff --git a/test/files/run/t5072.check b/test/files/run/t5072.check index ddd49c71cb..ab34e49869 100644 --- a/test/files/run/t5072.check +++ b/test/files/run/t5072.check @@ -7,4 +7,4 @@ defined class C scala> Thread.currentThread.getContextClassLoader.loadClass(classOf[C].getName) res0: Class[_] = class C -scala> +scala> :quit diff --git a/test/files/run/t5256c.check b/test/files/run/t5256c.check index 7fcd0eb722..3eb7b13a97 100644 --- a/test/files/run/t5256c.check +++ b/test/files/run/t5256c.check @@ -2,5 +2,5 @@ class A$1 Test.A$1 java.lang.Object { def foo(): Nothing - def <init>(): A$1 + def <init>(): Test.A$1 } diff --git a/test/files/run/t5256d.check b/test/files/run/t5256d.check index d42d234386..c2b49989ab 100644 --- a/test/files/run/t5256d.check +++ b/test/files/run/t5256d.check @@ -25,4 +25,4 @@ scala.AnyRef { def foo: scala.Nothing } -scala> +scala> :quit diff --git a/test/files/run/t5256h.scala b/test/files/run/t5256h.scala index f58aa6dbe7..435124a469 100644 --- a/test/files/run/t5256h.scala +++ b/test/files/run/t5256h.scala @@ -6,5 +6,6 @@ object Test extends App { val c = cm.classSymbol(mutant.getClass) println(c) println(c.fullName) - println(c.info) + // under -Xcheckinit there's an additional $init$ field + c.info.toString.lines.filter(_ != " private var bitmap$init$0: Boolean") foreach println } diff --git a/test/files/run/t5313.scala b/test/files/run/t5313.scala index 0d7168fa89..7f5af74c3f 100644 --- a/test/files/run/t5313.scala +++ b/test/files/run/t5313.scala @@ -11,7 +11,7 @@ object Test extends IcodeComparison { def bar = { var kept1 = new Object val result = new java.lang.ref.WeakReference(kept1) - kept1 = null // we can't eliminate this assigment because result can observe + kept1 = null // we can't eliminate this assignment because result can observe // when the object has no more references. See SI-5313 kept1 = new Object // but we can eliminate this one because kept1 has already been clobbered var erased2 = null // we can eliminate this store because it's never used diff --git a/test/files/run/t5428.check b/test/files/run/t5428.check index a46514ae7c..52fce09399 100644 --- a/test/files/run/t5428.check +++ b/test/files/run/t5428.check @@ -1,2 +1,2 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details Stack(8, 7, 6, 5, 4, 3) diff --git a/test/files/run/t5535.check b/test/files/run/t5535.check index a0c87a47f4..84097ccea9 100644 --- a/test/files/run/t5535.check +++ b/test/files/run/t5535.check @@ -13,4 +13,4 @@ f: Int => Int = <function1> scala> println(f(10)) 11 -scala> +scala> :quit diff --git a/test/files/run/t5537.check b/test/files/run/t5537.check index b9d521f301..98265ccc92 100644 --- a/test/files/run/t5537.check +++ b/test/files/run/t5537.check @@ -13,4 +13,4 @@ res2: List[scala.collection.immutable.List.type] = List() scala> List[Set.type]() res3: List[Set.type] = List() -scala> +scala> :quit diff --git a/test/files/run/t5583.check b/test/files/run/t5583.check index af96405bdd..32d285cbb3 100644 --- a/test/files/run/t5583.check +++ b/test/files/run/t5583.check @@ -13,4 +13,4 @@ scala> for (i <- 1 to 10) {s += i} scala> println(s) 165 -scala> +scala> :quit diff --git a/test/files/run/t5655.check b/test/files/run/t5655.check index 06c6b32599..4bbc54b641 100644 --- a/test/files/run/t5655.check +++ b/test/files/run/t5655.check @@ -23,4 +23,4 @@ and import x x ^ -scala> +scala> :quit diff --git a/test/files/run/t5665.scala b/test/files/run/t5665.scala new file mode 100644 index 0000000000..3ac498b5c0 --- /dev/null +++ b/test/files/run/t5665.scala @@ -0,0 +1,13 @@ +object O { + trait T { + private[this] val c: Int = 42 + def f = + { x: Int => c } + } +} + +object Test { + def main(args: Array[String]): Unit = { + assert(new O.T{}.f(0) == 42) + } +} diff --git a/test/files/run/t5699.scala b/test/files/run/t5699.scala index ec3b1d26b4..409bcd250c 100755 --- a/test/files/run/t5699.scala +++ b/test/files/run/t5699.scala @@ -1,21 +1,13 @@ -import scala.tools.partest.DirectTest +import scala.tools.partest.ParserTest import scala.reflect.internal.util.BatchSourceFile -object Test extends DirectTest { +object Test extends ParserTest { // Java code override def code = """ |public @interface MyAnnotation { String value(); } """.stripMargin - override def extraSettings: String = "-usejavacp -Ystop-after:typer -Xprint:parser" - - override def show(): Unit = { - // redirect err to out, for logging - val prevErr = System.err - System.setErr(System.out) - compile() - System.setErr(prevErr) - } + override def extraSettings: String = "-usejavacp -Ystop-after:namer -Xprint:parser" override def newSources(sourceCodes: String*) = { assert(sourceCodes.size == 1) diff --git a/test/files/run/t576.check b/test/files/run/t576.check index 6458d5d743..22f3843abf 100644 --- a/test/files/run/t576.check +++ b/test/files/run/t576.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details 1 2 3 diff --git a/test/files/run/t5789.check b/test/files/run/t5789.check index bcb2382559..193abfaff0 100644 --- a/test/files/run/t5789.check +++ b/test/files/run/t5789.check @@ -7,4 +7,4 @@ n: Int = 2 scala> () => n res0: () => Int = <function0> -scala> +scala> :quit diff --git a/test/files/run/t5830.check b/test/files/run/t5830.check index 675387eb8e..9260854676 100644 --- a/test/files/run/t5830.check +++ b/test/files/run/t5830.check @@ -1,5 +1,6 @@ a with oef a with oef +a with oef a def with oef def diff --git a/test/files/run/t5830.scala b/test/files/run/t5830.scala index 5d808bfa28..03b9c540e0 100644 --- a/test/files/run/t5830.scala +++ b/test/files/run/t5830.scala @@ -1,12 +1,11 @@ import scala.annotation.switch object Test extends App { - // TODO: should not emit a switch - // def noSwitch(ch: Char, eof: Boolean) = (ch: @switch) match { - // case 'a' if eof => println("a with oef") // then branch - // } + def noSwitch(ch: Char, eof: Boolean) = ch match { + case 'a' if eof => println("a with oef") // then branch + } - def onlyThen(ch: Char, eof: Boolean) = (ch: @switch) match { + def onlyThen(ch: Char, eof: Boolean) = ch match { case 'a' if eof => println("a with oef") // then branch case 'c' => } @@ -18,7 +17,7 @@ object Test extends App { case 'c' => } - def defaultUnguarded(ch: Char, eof: Boolean) = (ch: @switch) match { + def defaultUnguarded(ch: Char, eof: Boolean) = ch match { case ' ' if eof => println("spacey oef") case _ => println("default") } @@ -44,7 +43,7 @@ object Test extends App { // case 'c' => // } - // noSwitch('a', true) + noSwitch('a', true) onlyThen('a', true) // 'a with oef' ifThenElse('a', true) // 'a with oef' ifThenElse('a', false) // 'a' diff --git a/test/files/run/t5905-features.flags b/test/files/run/t5905-features.flags new file mode 100644 index 0000000000..ad51758c39 --- /dev/null +++ b/test/files/run/t5905-features.flags @@ -0,0 +1 @@ +-nowarn diff --git a/test/files/run/t5905-features.scala b/test/files/run/t5905-features.scala new file mode 100644 index 0000000000..b518d61145 --- /dev/null +++ b/test/files/run/t5905-features.scala @@ -0,0 +1,31 @@ + +import tools.partest.DirectTest + +// verify that all languageFeature names are accepted by -language +object Test extends DirectTest { + override def code = "class Code { def f = (1 to 10) size }" // exercise a feature to sanity-check coverage of -language options + + override def extraSettings = s"-usejavacp -d ${testOutput.path}" + + override def show() = { + val global = newCompiler("-Ystop-after:typer") + compileString(global)("") // warm me up, scotty + import global._ + exitingTyper { + //def isFeature(s: Symbol) = s.annotations.exists((a: AnnotationInfo) => a.tpe <:< typeOf[scala.annotation.meta.languageFeature]) + def isFeature(s: Symbol) = s hasAnnotation definitions.LanguageFeatureAnnot + val langf = definitions.languageFeatureModule.typeSignature + val feats = langf.declarations filter (s => isFeature(s)) map (_.name.decoded) + val xmen = langf.member(TermName("experimental")).typeSignature.declarations filter (s => isFeature(s)) map (s => s"experimental.${s.name.decoded}") + val all = (feats ++ xmen) mkString "," + + assert(feats.nonEmpty, "Test must find feature flags.") + + //compile("junk") // tragically, does not fail the test, i.e., arg must not be totally borked + + //dynamics,postfixOps,reflectiveCalls,implicitConversions,higherKinds,existentials,experimental.macros + compile(s"-language:$all") + } + } +} + diff --git a/test/files/run/t5905b-features.check b/test/files/run/t5905b-features.check new file mode 100644 index 0000000000..08c76d74aa --- /dev/null +++ b/test/files/run/t5905b-features.check @@ -0,0 +1 @@ +'noob' is not a valid choice for '-language' diff --git a/test/files/run/t5905b-features.scala b/test/files/run/t5905b-features.scala new file mode 100644 index 0000000000..627df8334b --- /dev/null +++ b/test/files/run/t5905b-features.scala @@ -0,0 +1,15 @@ + +import tools.partest.DirectTest + +// verify that only languageFeature names are accepted by -language +object Test extends DirectTest { + override def code = "class Code" + + override def extraSettings = s"-usejavacp -d ${testOutput.path}" + + override def show() = { + //compile("-language", "--") // no error + compile(s"-language:noob") + } +} + diff --git a/test/files/run/t5938.scala b/test/files/run/t5938.scala new file mode 100644 index 0000000000..59a95ac37f --- /dev/null +++ b/test/files/run/t5938.scala @@ -0,0 +1,35 @@ +import scala.tools.partest.DirectTest + +object Test extends DirectTest { + + override def extraSettings: String = + s"-usejavacp -d ${testOutput.path}" + + override def code = """ +object O extends C { + def main(args: Array[String]): Unit = { + } + // Static forwarder for foo and setter_foo_= added more once in a multi-run compile. +} + """.trim + + override def show(): Unit = { + val global = newCompiler() + Console.withErr(System.out) { + compileString(global)(code) + compileString(global)(code) + loadClass // was "duplicate name and signature in class X" + } + } + + def loadClass: Class[_] = { + val cl = new java.net.URLClassLoader(Array(testOutput.toFile.toURL)); + cl.loadClass("O") + } +} + +trait T { + val foo: String = "" +} +class C extends T + diff --git a/test/files/run/t6011c.scala b/test/files/run/t6011c.scala index 0647e3f81a..96a685b9cf 100644 --- a/test/files/run/t6011c.scala +++ b/test/files/run/t6011c.scala @@ -6,7 +6,7 @@ object Test extends App { // at scala.reflect.internal.SymbolTable.abort(SymbolTable.scala:50) // at scala.tools.nsc.Global.abort(Global.scala:249) // at scala.tools.nsc.backend.jvm.GenASM$JPlainBuilder$jcode$.emitSWITCH(GenASM.scala:1850) - ((1: Byte): @unchecked @annotation.switch) match { + ((1: Byte): @unchecked) match { case 1 => 2 case 1 => 3 // crash } diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check index a6c4db8f11..edc8b22d6d 100644 --- a/test/files/run/t6028.check +++ b/test/files/run/t6028.check @@ -24,7 +24,7 @@ package <empty> { (new <$anon: Function0>(T.this, tryyParam, tryyLocal): Function0) } }; - @SerialVersionUID(0) final <synthetic> class $anonfun$foo$1 extends scala.runtime.AbstractFunction0$mcI$sp with Serializable { + @SerialVersionUID(value = 0) final <synthetic> class $anonfun$foo$1 extends scala.runtime.AbstractFunction0$mcI$sp with Serializable { def <init>($outer: T, methodParam$1: Int, methodLocal$1: Int): <$anon: Function0> = { $anonfun$foo$1.super.<init>(); () @@ -60,7 +60,7 @@ package <empty> { }; scala.this.Predef.print(scala.Int.box(barParam$1)) }; - @SerialVersionUID(0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable { + @SerialVersionUID(value = 0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable { def <init>($outer: T, tryyParam$1: Int, tryyLocal$1: runtime.IntRef): <$anon: Function0> = { $anonfun$tryy$1.super.<init>(); () @@ -81,4 +81,4 @@ package <empty> { } } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details diff --git a/test/files/run/t6086-repl.check b/test/files/run/t6086-repl.check index 115eff5f85..b904f118e8 100644 --- a/test/files/run/t6086-repl.check +++ b/test/files/run/t6086-repl.check @@ -7,4 +7,4 @@ defined class X scala> scala.reflect.runtime.universe.typeOf[X] res0: reflect.runtime.universe.Type = X -scala> +scala> :quit diff --git a/test/files/run/t6111.check b/test/files/run/t6111.check index 1f23a87f73..5880658001 100644 --- a/test/files/run/t6111.check +++ b/test/files/run/t6111.check @@ -1,3 +1,3 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details (8,8) (x,x) diff --git a/test/files/run/t6114.scala b/test/files/run/t6114.scala index cb880ece00..8ad02d5bb2 100644 --- a/test/files/run/t6114.scala +++ b/test/files/run/t6114.scala @@ -51,7 +51,7 @@ object Test extends App { val next = list.asScala ++ List(4,5,6) assert(next != list.asScala) - // Note: Clone is hidden at this level, so no overriden cloning. + // Note: Clone is hidden at this level, so no overridden cloning. } testList diff --git a/test/files/run/t6146b.check b/test/files/run/t6146b.check index a3b09efcd9..6998873fb7 100644 --- a/test/files/run/t6146b.check +++ b/test/files/run/t6146b.check @@ -60,4 +60,4 @@ res2: u.Type = O.S3 scala> memType(S4, fTpe) res3: u.Type = S4 -scala> +scala> :quit diff --git a/test/files/run/t6187.check b/test/files/run/t6187.check index 0180125809..9a9e266ec6 100644 --- a/test/files/run/t6187.check +++ b/test/files/run/t6187.check @@ -29,4 +29,4 @@ res1: List[Int] = List(1) scala> List("") collect { case x => x } res2: List[String] = List("") -scala> +scala> :quit diff --git a/test/files/run/t6260c.check b/test/files/run/t6260c.check index 1a57f2d741..78e9b27371 100644 --- a/test/files/run/t6260c.check +++ b/test/files/run/t6260c.check @@ -1,5 +1,9 @@ f(C@2e) +#partest !-Ydelambdafy:method Test$$anonfun$$apply +#partest -Ydelambdafy:method +Test$lambda$1$$apply +#partest apply g(C@2e) diff --git a/test/files/run/t6273.check b/test/files/run/t6273.check index bef0b227d2..3b682800df 100644 --- a/test/files/run/t6273.check +++ b/test/files/run/t6273.check @@ -12,4 +12,4 @@ x: String = y = 55 " -scala> +scala> :quit diff --git a/test/files/run/t6292.check b/test/files/run/t6292.check index 6232ba7519..6f7430d5b8 100644 --- a/test/files/run/t6292.check +++ b/test/files/run/t6292.check @@ -1 +1 @@ -warning: there were 7 deprecation warning(s); re-run with -deprecation for details +warning: there were 7 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6318_primitives.check b/test/files/run/t6318_primitives.check index b330f91276..4bc5e598eb 100644 --- a/test/files/run/t6318_primitives.check +++ b/test/files/run/t6318_primitives.check @@ -1,36 +1,54 @@ -true +Checking if byte matches byte Some(1) -false +Checking if byte matches short None -true +Checking if class java.lang.Byte matches byte Some(1) -false +Checking if short matches short +Some(1) +Checking if short matches char None -true +Checking if class java.lang.Short matches short +Some(1) +Checking if char matches char Some() -false +Checking if char matches int None -true +Checking if class java.lang.Character matches char +Some() +Checking if int matches int Some(1) -false +Checking if int matches long None -true +Checking if class java.lang.Integer matches int Some(1) -false +Checking if long matches long +Some(1) +Checking if long matches float None -true +Checking if class java.lang.Long matches long +Some(1) +Checking if float matches float Some(1.0) -false +Checking if float matches double None -true +Checking if class java.lang.Float matches float Some(1.0) -false +Checking if double matches double +Some(1.0) +Checking if double matches boolean None -true +Checking if class java.lang.Double matches double +Some(1.0) +Checking if boolean matches boolean Some(true) -false +Checking if boolean matches void None -true +Checking if class java.lang.Boolean matches boolean +Some(true) +Checking if void matches void Some(()) -false +Checking if void matches byte None +Checking if class scala.runtime.BoxedUnit matches void +Some(()) diff --git a/test/files/run/t6318_primitives.scala b/test/files/run/t6318_primitives.scala index 30f27120b3..bc8ec88359 100644 --- a/test/files/run/t6318_primitives.scala +++ b/test/files/run/t6318_primitives.scala @@ -2,70 +2,88 @@ import scala.reflect.{ClassTag, classTag} object Test extends App { def test[T: ClassTag](x: T) { - println(classTag[T].runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[T].runtimeClass}") println(classTag[T].unapply(x)) } { val x = 1.toByte - println(ClassTag.Byte.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Byte].runtimeClass}") println(ClassTag.Byte.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Short].runtimeClass}") + println(ClassTag.Short.unapply(x)) test(x) } { val x = 1.toShort - println(ClassTag.Short.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Short].runtimeClass}") println(ClassTag.Short.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Char].runtimeClass}") + println(ClassTag.Char.unapply(x)) test(x) } { val x = 1.toChar - println(ClassTag.Char.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Char].runtimeClass}") println(ClassTag.Char.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Int].runtimeClass}") + println(ClassTag.Int.unapply(x)) test(x) } { val x = 1.toInt - println(ClassTag.Int.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Int].runtimeClass}") println(ClassTag.Int.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Long].runtimeClass}") + println(ClassTag.Long.unapply(x)) test(x) } { val x = 1.toLong - println(ClassTag.Long.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Long].runtimeClass}") println(ClassTag.Long.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Float].runtimeClass}") + println(ClassTag.Float.unapply(x)) test(x) } { val x = 1.toFloat - println(ClassTag.Float.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Float].runtimeClass}") println(ClassTag.Float.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Double].runtimeClass}") + println(ClassTag.Double.unapply(x)) test(x) } { val x = 1.toDouble - println(ClassTag.Double.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Double].runtimeClass}") println(ClassTag.Double.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Boolean].runtimeClass}") + println(ClassTag.Boolean.unapply(x)) test(x) } { val x = true - println(ClassTag.Boolean.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Boolean].runtimeClass}") println(ClassTag.Boolean.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Unit].runtimeClass}") + println(ClassTag.Unit.unapply(x)) test(x) } { val x = () - println(ClassTag.Unit.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Unit].runtimeClass}") println(ClassTag.Unit.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Byte].runtimeClass}") + println(ClassTag.Byte.unapply(x)) test(x) } -}
\ No newline at end of file +} diff --git a/test/files/run/t6320.check b/test/files/run/t6320.check index 013acc1c54..af7c865690 100644 --- a/test/files/run/t6320.check +++ b/test/files/run/t6320.check @@ -10,4 +10,4 @@ defined class Dyn scala> new Dyn(Map("foo" -> 10)).foo[Int] res0: Int = 10 -scala> +scala> :quit diff --git a/test/files/run/t6327.flags b/test/files/run/t6327.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/run/t6327.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/t6329_repl.check b/test/files/run/t6329_repl.check index 5049426ab4..ebb1aace7c 100644 --- a/test/files/run/t6329_repl.check +++ b/test/files/run/t6329_repl.check @@ -5,31 +5,31 @@ scala> import scala.reflect.classTag import scala.reflect.classTag scala> classManifest[scala.List[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res0: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[<?>] scala> classTag[scala.List[_]] res1: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List scala> classManifest[scala.collection.immutable.List[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res2: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[<?>] scala> classTag[scala.collection.immutable.List[_]] res3: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List scala> classManifest[Predef.Set[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res4: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set[<?>] scala> classTag[Predef.Set[_]] res5: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set scala> classManifest[scala.collection.immutable.Set[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res6: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set[<?>] scala> classTag[scala.collection.immutable.Set[_]] res7: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set -scala> +scala> :quit diff --git a/test/files/run/t6329_repl_bug.check b/test/files/run/t6329_repl_bug.check index 44c41cfd03..84297a629f 100644 --- a/test/files/run/t6329_repl_bug.check +++ b/test/files/run/t6329_repl_bug.check @@ -8,10 +8,10 @@ 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 +warning: there was one deprecation warning; 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> +scala> :quit diff --git a/test/files/run/t6329_vanilla_bug.check b/test/files/run/t6329_vanilla_bug.check index 640d168a8a..01bf0636ea 100644 --- a/test/files/run/t6329_vanilla_bug.check +++ b/test/files/run/t6329_vanilla_bug.check @@ -1,3 +1,3 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details scala.collection.immutable.List[<?>] scala.collection.immutable.List diff --git a/test/files/run/t6381.check b/test/files/run/t6381.check index 4ed11d59ff..49c6a784ad 100644 --- a/test/files/run/t6381.check +++ b/test/files/run/t6381.check @@ -16,4 +16,4 @@ defined term macro pos: String scala> pos res0: String = class scala.reflect.internal.util.RangePosition -scala> +scala> :quit diff --git a/test/files/run/t6434.check b/test/files/run/t6434.check index f898b6b781..0a75ae2bd5 100644 --- a/test/files/run/t6434.check +++ b/test/files/run/t6434.check @@ -7,4 +7,4 @@ f: (x: => Int)Int scala> f _ res0: (=> Int) => Int = <function1> -scala> +scala> :quit diff --git a/test/files/run/t6439.check b/test/files/run/t6439.check index f8d5b3a8cd..c4b7591069 100644 --- a/test/files/run/t6439.check +++ b/test/files/run/t6439.check @@ -70,4 +70,4 @@ defined object lookup scala> lookup("F") // this now works as a result of changing .typeSymbol to .typeSymbolDirect in IMain#Request#definedSymbols res0: $r.intp.global.Symbol = type F -scala> +scala> :quit diff --git a/test/files/run/t6440.check b/test/files/run/t6440.check index 27d5d1380e..4d8618182b 100644 --- a/test/files/run/t6440.check +++ b/test/files/run/t6440.check @@ -1,4 +1,4 @@ -pos: source-newSource1.scala,line-9,offset=109 bad symbolic reference to <root>.pack1 encountered in class file 'U.class'. -Cannot access term pack1 in package <root>. The current classpath may be -missing a definition for <root>.pack1, or U.class may have been compiled against a version that's -incompatible with the one found on the current classpath. ERROR +pos: source-newSource1.scala,line-9,offset=109 reference to U is ambiguous; +it is imported twice in the same scope by +import pack2._ +and import X._ ERROR diff --git a/test/files/run/t6440.scala b/test/files/run/t6440.scala index 5a3a4150d9..94eda3642e 100644 --- a/test/files/run/t6440.scala +++ b/test/files/run/t6440.scala @@ -41,7 +41,7 @@ object Test extends StoreReporterDirectTest { assert(tClass.delete()) assert(pack1.delete()) - // bad symbolic reference error expected (but no stack trace!) + // should report ambiguous import, despite the fact that a parent of pack2.U is absent compileCode(app) println(filteredInfos.mkString("\n")) } diff --git a/test/files/run/t6440b.check b/test/files/run/t6440b.check index 0b642c2c35..a6100d6d1e 100644 --- a/test/files/run/t6440b.check +++ b/test/files/run/t6440b.check @@ -1,4 +1,5 @@ -pos: NoPosition bad symbolic reference to pack1.T encountered in class file 'U.class'. -Cannot access type T in package pack1. The current classpath may be -missing a definition for pack1.T, or U.class may have been compiled against a version that's -incompatible with the one found on the current classpath. ERROR +pos: NoPosition missing or invalid dependency detected while loading class file 'U.class'. +Could not access type T in package pack1, +because it (or its dependencies) are missing. Check your build definition for +missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.) +A full rebuild may help if 'U.class' was compiled against an incompatible version of pack1. ERROR diff --git a/test/files/run/t6481.check b/test/files/run/t6481.check index df40722242..4a3f6f7ee9 100644 --- a/test/files/run/t6481.check +++ b/test/files/run/t6481.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details delayed init new foo(1, 2) delayed init diff --git a/test/files/run/t6502.scala b/test/files/run/t6502.scala new file mode 100644 index 0000000000..52fabef6b8 --- /dev/null +++ b/test/files/run/t6502.scala @@ -0,0 +1,146 @@ +import scala.tools.nsc.Settings +import scala.tools.nsc.interpreter.ILoop +import scala.tools.nsc.settings.ClassPathRepresentationType +import scala.tools.partest._ + +object Test extends StoreReporterDirectTest { + def code = ??? + + def compileCode(code: String, jarFileName: String) = { + val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") + compileString(newCompiler("-cp", classpath, "-d", s"${testOutput.path}/$jarFileName"))(code) + } + + // TODO flat classpath doesn't support the classpath invalidation yet so we force using the recursive one + // it's the only test which needed such a workaround + override def settings = { + val settings = new Settings + settings.YclasspathImpl.value = ClassPathRepresentationType.Recursive + settings + } + + def app1 = """ + package test + + object Test extends App { + def test(): Unit = { + println("testing...") + } + }""" + + def app2 = """ + package test + + object Test extends App { + def test(): Unit = { + println("testing differently...") + } + }""" + + def app3 = """ + package test + + object Test3 extends App { + def test(): Unit = { + println("new object in existing package") + } + }""" + + def app6 = """ + package test6 + class A extends Test { println("created test6.A") } + class Z extends Test { println("created test6.Z") } + trait Test""" + + def test1(): Unit = { + val jar = "test1.jar" + compileCode(app1, jar) + + val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar", "test.Test.test()") + val output = ILoop.run(codeToRun, settings) + val lines = output.split("\n") + assert { + lines(4).contains("Added") && lines(4).contains("test1.jar") + } + assert { + lines(lines.length-3).contains("testing...") + } + } + + def test2(): Unit = { + // should reject jars with conflicting entries + val jar1 = "test1.jar" + val jar2 = "test2.jar" + compileCode(app2, jar2) + + val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar2") + val output = ILoop.run(codeToRun, settings) + val lines = output.split("\n") + assert { + lines(4).contains("Added") && lines(4).contains("test1.jar") + } + assert { + lines(lines.length-3).contains("test2.jar") && lines(lines.length-3).contains("existing classpath entries conflict") + } + } + + def test3(): Unit = { + // should accept jars with overlapping packages, but no conflicts + val jar1 = "test1.jar" + val jar3 = "test3.jar" + compileCode(app3, jar3) + + val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar3", "test.Test3.test()") + val output = ILoop.run(codeToRun, settings) + val lines = output.split("\n") + assert { + lines(4).contains("Added") && lines(4).contains("test1.jar") + } + assert { + lines(lines.length-3).contains("new object in existing package") + } + } + + def test4(): Unit = { + // twice the same jar should be rejected + val jar1 = "test1.jar" + val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar1") + val output = ILoop.run(codeToRun, settings) + val lines = output.split("\n") + assert { + lines(4).contains("Added") && lines(4).contains("test1.jar") + } + assert { + lines(lines.length-3).contains("test1.jar") && lines(lines.length-3).contains("existing classpath entries conflict") + } + } + + def test5(): Unit = { + val codeToRun = ":require /does/not/exist.jar" + val output = ILoop.run(codeToRun, settings) + assert(!output.contains("NullPointerException"), output) + assert(output.contains("Cannot load '/does/not/exist.jar'"), output) + } + + def test6(): Unit = { + // Avoid java.lang.NoClassDefFoundError triggered by the old appoach of using a Java + // classloader to parse .class files in order to read their names. + val jar = "test6.jar" + compileCode(app6, jar) + val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar", "import test6._; new A; new Z") + val output = ILoop.run(codeToRun, settings) + assert(output.contains("created test6.A"), output) + assert(output.contains("created test6.Z"), output) + } + + def show(): Unit = { + test1() + test2() + test3() + test4() + test5() + test6() + } + + def toCodeInSeparateLines(lines: String*): String = lines mkString "\n" +} diff --git a/test/files/run/t6507.check b/test/files/run/t6507.check index 3536c42381..5da4aa3a24 100644 --- a/test/files/run/t6507.check +++ b/test/files/run/t6507.check @@ -21,4 +21,4 @@ scala> res0 ! res1: A = A -scala> +scala> :quit diff --git a/test/files/run/t6541-option.scala b/test/files/run/t6541-option.scala new file mode 100644 index 0000000000..2c10c9e09d --- /dev/null +++ b/test/files/run/t6541-option.scala @@ -0,0 +1,19 @@ +import scala.tools.partest.ReplTest + +object Test extends ReplTest { + def code = """ +:setting -Xsource:2.12 +case class C12(clazz: Class[_]) +val o: Option[Class[T] forSome { type T}] = C12.unapply(C12(classOf[String])) + +:setting -Xsource:2.11 +import scala.language.existentials +case class C11(clazz: Class[_]) +val o: Option[Class[T]] forSome { type T } = C11.unapply(C11(classOf[String])) + """ + + override def show() = { + val r = eval().mkString("\n") + assert(!(r.contains("warning") || r.contains("error")), r) + } +} diff --git a/test/files/run/t6541.flags b/test/files/run/t6541.flags new file mode 100644 index 0000000000..68d0ddfec2 --- /dev/null +++ b/test/files/run/t6541.flags @@ -0,0 +1 @@ +-feature -Xfatal-warnings -Xsource:2.12
\ No newline at end of file diff --git a/test/files/run/t6541.scala b/test/files/run/t6541.scala new file mode 100644 index 0000000000..f127143691 --- /dev/null +++ b/test/files/run/t6541.scala @@ -0,0 +1,25 @@ +class A +class B[T](x: T) +case class C(a: A, b: B[_]) + +case class D(a: A, b: B[_]*) + +case class E(c: Class[_]) + +object Test extends App { + def f1(c: C) = c match { + case C(a, b) => () + } + + def f2(d: D) = d match { + case D(a, b1, b2) => () + } + + def f3(e: E) = e match { + case E(c) => () + } + + f1(C(new A, new B(1))) + f2(D(new A, new B(1), new B(2))) + f3(E(classOf[E])) +} diff --git a/test/files/run/t6549.check b/test/files/run/t6549.check index d5dfc5ebe8..be3445927e 100644 --- a/test/files/run/t6549.check +++ b/test/files/run/t6549.check @@ -25,4 +25,4 @@ m(scala.Symbol("s")).xxx: Any = 's scala> val `"` = 0 ": Int = 0 -scala> +scala> :quit diff --git a/test/files/run/t6555.check b/test/files/run/t6555.check index 9ac115a13f..e3b467ce7c 100644 --- a/test/files/run/t6555.check +++ b/test/files/run/t6555.check @@ -6,7 +6,7 @@ package <empty> { () }; private[this] val f: Int => Int = { - @SerialVersionUID(0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1$mcII$sp with Serializable { + @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1$mcII$sp with Serializable { def <init>(): <$anon: Int => Int> = { $anonfun.super.<init>(); () diff --git a/test/files/run/t6622.check b/test/files/run/t6622.check new file mode 100644 index 0000000000..5d006d88e6 --- /dev/null +++ b/test/files/run/t6622.check @@ -0,0 +1,10 @@ + O1.resultVal isMemberClass = false, null +class A$1 + O1.resultDef isMemberClass = false, public void O1$.resultDef() +class A$2 + C2.resultVal isMemberClass = false, null +class $B$1 + O3.resultDef isMemberClass = false, public void O3$.resultDef() +class C$1 + O4.resultDefDefault isMemberClass = false, public java.lang.Object O4$.resultDefDefault$default$1() +class C$2 diff --git a/test/files/run/t6622.scala b/test/files/run/t6622.scala new file mode 100644 index 0000000000..de8ffa01bf --- /dev/null +++ b/test/files/run/t6622.scala @@ -0,0 +1,50 @@ +import Test.check + +object O1 { + lazy val resultVal = { + class A + check("O1.resultVal", classOf[A]) + } + + def resultDef = { + class A + check("O1.resultDef", classOf[A]) + } +} + +class C2 { + val resultVal = { + val tmp = { + class B + check("C2.resultVal", classOf[B]) + } + } +} + +object O3 { + def resultDef = { + class C + check("O3.resultDef", classOf[C]) + } +} + +object O4 { + def resultDefDefault(a: Any = { + class C + check("O4.resultDefDefault", classOf[C]) + }) = (); +} + + +object Test extends App { + def check(desc: String, clazz: Class[_]) { + println(s" $desc isMemberClass = ${clazz.isMemberClass}, ${clazz.getEnclosingMethod}") + println(reflect.runtime.currentMirror.classSymbol(clazz)) + } + + O1.resultVal + O1.resultDef + new C2().resultVal + O3.resultDef + O4.resultDefDefault() +} diff --git a/test/files/run/t6631.scala b/test/files/run/t6631.scala deleted file mode 100644 index e472b83d50..0000000000 --- a/test/files/run/t6631.scala +++ /dev/null @@ -1,18 +0,0 @@ -import reflect.ClassTag - -object Test extends App { - def intercept[T <: Throwable : ClassTag](act: => Any) = try { - act - } catch { - case x: Throwable => - val cls = implicitly[ClassTag[T]].runtimeClass - assert(cls.isInstance(x), (x.getClass, x, cls).toString) - } - assert(s"""\f\r\n\t""" == "\f\r\n\t") - - import StringContext.InvalidEscapeException - intercept[InvalidEscapeException](s"""\""") - intercept[InvalidEscapeException](s"""\x""") - intercept[InvalidEscapeException](s"\") - -} diff --git a/test/files/run/t6663.flags b/test/files/run/t6663.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/run/t6663.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/t6669.scala b/test/files/run/t6669.scala index e18f2514a9..27c4970d60 100644 --- a/test/files/run/t6669.scala +++ b/test/files/run/t6669.scala @@ -1,4 +1,5 @@ import java.io.{ByteArrayOutputStream, PrintStream} +import scala.reflect.io.File object Test extends App { val baos = new ByteArrayOutputStream() @@ -9,9 +10,11 @@ object Test extends App { scala.tools.scalap.Main.main(Array("-verbose", "java.lang.Object")) } + val currentLocationCpFragment = File.pathSeparator + "." + // now make sure we saw the '.' in the classpath val msg1 = baos.toString() - assert(msg1 contains "directory classpath: .", s"Did not see '.' in the default class path. Full results were:\n$msg1") + assert(msg1 contains currentLocationCpFragment, s"Did not see '.' in the default class path. Full results were:\n$msg1") // then test again with a user specified classpath baos.reset @@ -22,5 +25,5 @@ object Test extends App { // now make sure we did not see the '.' in the classpath val msg2 = baos.toString() - assert(!(msg2 contains "directory classpath: ."), s"Did saw '.' in the user specified class path. Full results were:\n$msg2") + assert(!(msg2 contains currentLocationCpFragment), s"Did saw '.' in the user specified class path. Full results were:\n$msg2") } diff --git a/test/files/run/t6690.check b/test/files/run/t6690.check index a92ddc0e51..a9ecc29fea 100644 --- a/test/files/run/t6690.check +++ b/test/files/run/t6690.check @@ -1 +1 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6731.flags b/test/files/run/t6731.flags new file mode 100644 index 0000000000..ea7fc37e1a --- /dev/null +++ b/test/files/run/t6731.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/t6863.check b/test/files/run/t6863.check index fea22b582f..d4df5f7a74 100644 --- a/test/files/run/t6863.check +++ b/test/files/run/t6863.check @@ -10,4 +10,4 @@ t6863.scala:46: warning: comparing values of types Unit and Unit using `==' will t6863.scala:59: warning: comparing values of types Unit and Unit using `==' will always yield true assert({ () => x }.apply == ()) ^ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6935.check b/test/files/run/t6935.check index 844ca54682..df1629dd7e 100644 --- a/test/files/run/t6935.check +++ b/test/files/run/t6935.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details diff --git a/test/files/run/t6937.check b/test/files/run/t6937.check index 4729dc7006..5c5d4485b6 100644 --- a/test/files/run/t6937.check +++ b/test/files/run/t6937.check @@ -19,4 +19,4 @@ apiru: scala.reflect.api.Universe = <lazy> scala> apiru.typeTag[A].in(cm) res0: reflect.runtime.universe.TypeTag[A] = TypeTag[A] -scala> +scala> :quit diff --git a/test/files/run/t6988.check b/test/files/run/t6988.check new file mode 100644 index 0000000000..5db04832d6 --- /dev/null +++ b/test/files/run/t6988.check @@ -0,0 +1,2 @@ +#1 13 +#2 13 diff --git a/test/files/run/t6988.scala b/test/files/run/t6988.scala new file mode 100644 index 0000000000..45dfe33461 --- /dev/null +++ b/test/files/run/t6988.scala @@ -0,0 +1,9 @@ +case class User() + +@SerialVersionUID(13l) case class IdentifyMessage1(userName: String, user: User, code: Int) +@SerialVersionUID(10l + 3l) case class IdentifyMessage2(userName: String, user: User, code: Int) + +object Test extends App { + println("#1 " + java.io.ObjectStreamClass.lookup(IdentifyMessage1("hei", User(), 8).getClass).getSerialVersionUID) + println("#2 " + java.io.ObjectStreamClass.lookup(IdentifyMessage2("hei", User(), 8).getClass).getSerialVersionUID) +} diff --git a/test/files/run/t7019.scala b/test/files/run/t7019.scala new file mode 100644 index 0000000000..5dcc09d2b6 --- /dev/null +++ b/test/files/run/t7019.scala @@ -0,0 +1,10 @@ +final class Foo(val i: Int) extends AnyVal { + def foo() = go(i) + private[this] def go(i: Int) = i * 2 +} + +object Test { + def main(args: Array[String]): Unit = { + assert(new Foo(1).foo() == 2) + } +} diff --git a/test/files/run/t7096.scala b/test/files/run/t7096.scala index e7a894fc23..f723d70abe 100644 --- a/test/files/run/t7096.scala +++ b/test/files/run/t7096.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warning; re-run with */ import scala.tools.partest._ import scala.tools.nsc._ diff --git a/test/files/run/t7185.check b/test/files/run/t7185.check index ebf85b731f..e4f80a8ff9 100644 --- a/test/files/run/t7185.check +++ b/test/files/run/t7185.check @@ -29,4 +29,4 @@ res0: Any = } } -scala> +scala> :quit diff --git a/test/files/run/t7319.check b/test/files/run/t7319.check index b7443aa0c4..e35cfc90c0 100644 --- a/test/files/run/t7319.check +++ b/test/files/run/t7319.check @@ -5,15 +5,15 @@ scala> class M[A] defined class M scala> implicit def ma0[A](a: A): M[A] = null -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details ma0: [A](a: A)M[A] scala> implicit def ma1[A](a: A): M[A] = null -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details ma1: [A](a: A)M[A] scala> def convert[F[X <: F[X]]](builder: F[_ <: F[_]]) = 0 -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details convert: [F[X <: F[X]]](builder: F[_ <: F[_]])Int scala> convert(Some[Int](0)) @@ -40,4 +40,4 @@ scala> Range(1,2).toArray: Seq[_] scala> 0 res2: Int = 0 -scala> +scala> :quit diff --git a/test/files/run/t7407.flags b/test/files/run/t7407.flags index c8547a27dc..ffc65f4b81 100644 --- a/test/files/run/t7407.flags +++ b/test/files/run/t7407.flags @@ -1 +1 @@ --Ynooptimise -Ybackend:GenBCode +-Yopt:l:none -Ybackend:GenBCode diff --git a/test/files/run/t7407b.flags b/test/files/run/t7407b.flags index c8547a27dc..c30091d3de 100644 --- a/test/files/run/t7407b.flags +++ b/test/files/run/t7407b.flags @@ -1 +1 @@ --Ynooptimise -Ybackend:GenBCode +-Ybackend:GenBCode diff --git a/test/files/run/t7459a.scala b/test/files/run/t7459a.scala new file mode 100644 index 0000000000..e9653c6e79 --- /dev/null +++ b/test/files/run/t7459a.scala @@ -0,0 +1,14 @@ +class LM { + class Node[B1] + case class CC(n: LM) + + // crash + val f: (LM => Any) = { + case tttt => + new tttt.Node[Any]() + } +} + +object Test extends App { + new LM().f(new LM()) +} diff --git a/test/files/run/t7459b-optimize.flags b/test/files/run/t7459b-optimize.flags new file mode 100644 index 0000000000..49d036a887 --- /dev/null +++ b/test/files/run/t7459b-optimize.flags @@ -0,0 +1 @@ +-optimize diff --git a/test/files/run/t7459b-optimize.scala b/test/files/run/t7459b-optimize.scala new file mode 100644 index 0000000000..605890962c --- /dev/null +++ b/test/files/run/t7459b-optimize.scala @@ -0,0 +1,21 @@ +class LM { + class Node[B1] + + // crash + val g: (CC => Any) = { + case CC(tttt) => + new tttt.Node[Any]() + } + + val h: (Some[CC] => Any) = { + case Some(CC(tttt)) => + new tttt.Node[Any]() + } +} + +object Test extends App { + new LM().g(new CC(new LM())) + new LM().h(Some(new CC(new LM()))) +} +case class CC(n: LM) + diff --git a/test/files/run/t7459b.scala b/test/files/run/t7459b.scala new file mode 100644 index 0000000000..605890962c --- /dev/null +++ b/test/files/run/t7459b.scala @@ -0,0 +1,21 @@ +class LM { + class Node[B1] + + // crash + val g: (CC => Any) = { + case CC(tttt) => + new tttt.Node[Any]() + } + + val h: (Some[CC] => Any) = { + case Some(CC(tttt)) => + new tttt.Node[Any]() + } +} + +object Test extends App { + new LM().g(new CC(new LM())) + new LM().h(Some(new CC(new LM()))) +} +case class CC(n: LM) + diff --git a/test/files/run/t7459c.scala b/test/files/run/t7459c.scala new file mode 100644 index 0000000000..144c5d793b --- /dev/null +++ b/test/files/run/t7459c.scala @@ -0,0 +1,16 @@ +class LM { + class Node[B1] + + // crash + val g: (CC => Any) = { + case CC(tttt) => + tttt.## // no crash + new tttt.Node[Any]() + } +} + +object Test extends App { + new LM().g(new CC(new LM())) +} +case class CC(n: LM) + diff --git a/test/files/run/t7459d.scala b/test/files/run/t7459d.scala new file mode 100644 index 0000000000..3263701f9d --- /dev/null +++ b/test/files/run/t7459d.scala @@ -0,0 +1,15 @@ +class LM { + class Node[B1] + case class CC(n: LM) + + // crash + val f: (LM => Any) = { + case tttt => + val uuuu: (tttt.type, Any) = (tttt, 0) + new uuuu._1.Node[Any]() + } +} + +object Test extends App { + new LM().f(new LM()) +} diff --git a/test/files/run/t7459f.scala b/test/files/run/t7459f.scala new file mode 100644 index 0000000000..63e2109560 --- /dev/null +++ b/test/files/run/t7459f.scala @@ -0,0 +1,12 @@ +object Test extends App { + class C + + case class FooSeq(x: Int, y: String, z: C*) + + FooSeq(1, "a", new C()) match { + case FooSeq(1, "a", x@_* ) => + //println(x.toList) + x.asInstanceOf[x.type] + assert(x.isInstanceOf[x.type]) + } +} diff --git a/test/files/run/t7482a.check b/test/files/run/t7482a.check index 943538f352..a21ef7b68f 100644 --- a/test/files/run/t7482a.check +++ b/test/files/run/t7482a.check @@ -7,4 +7,4 @@ v: java.util.ArrayList[String] = [] scala> val v: java.util.ArrayList[String] = new java.util.ArrayList[String](5) v: java.util.ArrayList[String] = [] -scala> +scala> :quit diff --git a/test/files/run/t7582.check b/test/files/run/t7582.check index 225fb1ace8..2a11210000 100644 --- a/test/files/run/t7582.check +++ b/test/files/run/t7582.check @@ -1,2 +1,6 @@ -warning: there were 1 inliner warning(s); re-run with -Yinline-warnings for details +#partest !-Ybackend:GenBCode +warning: there was one inliner warning; re-run with -Yinline-warnings for details +#partest -Ybackend:GenBCode +warning: there was one inliner warning; re-run with -Yopt-warnings for details +#partest 2 diff --git a/test/files/run/t7582b.check b/test/files/run/t7582b.check index 225fb1ace8..2a11210000 100644 --- a/test/files/run/t7582b.check +++ b/test/files/run/t7582b.check @@ -1,2 +1,6 @@ -warning: there were 1 inliner warning(s); re-run with -Yinline-warnings for details +#partest !-Ybackend:GenBCode +warning: there was one inliner warning; re-run with -Yinline-warnings for details +#partest -Ybackend:GenBCode +warning: there was one inliner warning; re-run with -Yopt-warnings for details +#partest 2 diff --git a/test/files/run/t7634.check b/test/files/run/t7634.check index aea3b94da5..9c6b8b47dd 100644 --- a/test/files/run/t7634.check +++ b/test/files/run/t7634.check @@ -5,4 +5,4 @@ Type :help for more information. scala> .lines res1: List[String] = List(shello, world.) -scala> +scala> :quit diff --git a/test/files/run/t7741a/GroovyInterface$1Dump.java b/test/files/run/t7741a/GroovyInterface$1Dump.java new file mode 100644 index 0000000000..0c0eab3f1b --- /dev/null +++ b/test/files/run/t7741a/GroovyInterface$1Dump.java @@ -0,0 +1,222 @@ +import java.util.*; +import scala.tools.asm.*; + +// generated with +// git clone alewando/scala_groovy_interop +// SCALA_HOME=... GROOVY_HOME=... ant +// cd /code/scala2 +// java -classpath build/asm/classes:/Users/jason/code/scala_groovy_interop/classes:/code/scala2/build/pack/lib/scala-library.jar:/usr/local/Cellar/groovy/2.4.1/libexec/embeddable/groovy-all-2.4.1.jar scala.tools.asm.util.ASMifier 'GroovyInterface$1' +// java -classpath build/asm/classes:/Users/jason/code/scala_groovy_interop/classes:/code/scala2/build/pack/lib/scala-library.jar:/usr/local/Cellar/groovy/2.4.1/libexec/embeddable/groovy-all-2.4.1.jar scala.tools.asm.util.ASMifier 'GroovyInterface$1' +public class GroovyInterface$1Dump implements Opcodes { + + public static byte[] dump () throws Exception { + + ClassWriter cw = new ClassWriter(0); + FieldVisitor fv; + MethodVisitor mv; + AnnotationVisitor av0; + + cw.visit(V1_5, ACC_SUPER + ACC_SYNTHETIC, "GroovyInterface$1", null, "java/lang/Object", new String[] {}); + + cw.visitInnerClass("GroovyInterface$1", "GroovyInterface", "1", ACC_SYNTHETIC); + + { + fv = cw.visitField(ACC_STATIC + ACC_SYNTHETIC, "$class$GroovyInterface", "Ljava/lang/Class;", null, null); + fv.visitEnd(); + } + { + fv = cw.visitField(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$staticClassInfo", "Lorg/codehaus/groovy/reflection/ClassInfo;", null, null); + fv.visitEnd(); + } + { + fv = cw.visitField(ACC_PUBLIC + ACC_STATIC + ACC_TRANSIENT + ACC_SYNTHETIC, "__$stMC", "Z", null, null); + fv.visitEnd(); + } + { + fv = cw.visitField(ACC_PRIVATE + ACC_TRANSIENT + ACC_SYNTHETIC, "metaClass", "Lgroovy/lang/MetaClass;", null, null); + fv.visitEnd(); + } + { + fv = cw.visitField(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$callSiteArray", "Ljava/lang/ref/SoftReference;", null, null); + fv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false); + mv.visitMethodInsn(INVOKESTATIC, "GroovyInterface$1", "$getCallSiteArray", "()[Lorg/codehaus/groovy/runtime/callsite/CallSite;", false); + mv.visitVarInsn(ASTORE, 1); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, "GroovyInterface$1", "$getStaticMetaClass", "()Lgroovy/lang/MetaClass;", false); + mv.visitVarInsn(ASTORE, 2); + mv.visitVarInsn(ALOAD, 2); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(SWAP); + mv.visitFieldInsn(PUTFIELD, "GroovyInterface$1", "metaClass", "Lgroovy/lang/MetaClass;"); + mv.visitVarInsn(ALOAD, 2); + mv.visitInsn(POP); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 3); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PROTECTED + ACC_SYNTHETIC, "$getStaticMetaClass", "()Lgroovy/lang/MetaClass;", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;", false); + mv.visitLdcInsn(Type.getType("LGroovyInterface$1;")); + Label l0 = new Label(); + mv.visitJumpInsn(IF_ACMPEQ, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/ScriptBytecodeAdapter", "initMetaClass", "(Ljava/lang/Object;)Lgroovy/lang/MetaClass;", false); + mv.visitInsn(ARETURN); + mv.visitLabel(l0); + mv.visitFieldInsn(GETSTATIC, "GroovyInterface$1", "$staticClassInfo", "Lorg/codehaus/groovy/reflection/ClassInfo;"); + mv.visitVarInsn(ASTORE, 1); + mv.visitVarInsn(ALOAD, 1); + Label l1 = new Label(); + mv.visitJumpInsn(IFNONNULL, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;", false); + mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/reflection/ClassInfo", "getClassInfo", "(Ljava/lang/Class;)Lorg/codehaus/groovy/reflection/ClassInfo;", false); + mv.visitInsn(DUP); + mv.visitVarInsn(ASTORE, 1); + mv.visitFieldInsn(PUTSTATIC, "GroovyInterface$1", "$staticClassInfo", "Lorg/codehaus/groovy/reflection/ClassInfo;"); + mv.visitLabel(l1); + mv.visitVarInsn(ALOAD, 1); + mv.visitMethodInsn(INVOKEVIRTUAL, "org/codehaus/groovy/reflection/ClassInfo", "getMetaClass", "()Lgroovy/lang/MetaClass;", false); + mv.visitInsn(ARETURN); + mv.visitMaxs(2, 2); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC + ACC_SYNTHETIC, "getMetaClass", "()Lgroovy/lang/MetaClass;", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, "GroovyInterface$1", "metaClass", "Lgroovy/lang/MetaClass;"); + mv.visitInsn(DUP); + Label l0 = new Label(); + mv.visitJumpInsn(IFNULL, l0); + mv.visitInsn(ARETURN); + mv.visitLabel(l0); + mv.visitInsn(POP); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(DUP); + mv.visitMethodInsn(INVOKEVIRTUAL, "GroovyInterface$1", "$getStaticMetaClass", "()Lgroovy/lang/MetaClass;", false); + mv.visitFieldInsn(PUTFIELD, "GroovyInterface$1", "metaClass", "Lgroovy/lang/MetaClass;"); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, "GroovyInterface$1", "metaClass", "Lgroovy/lang/MetaClass;"); + mv.visitInsn(ARETURN); + mv.visitMaxs(2, 1); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC + ACC_SYNTHETIC, "setMetaClass", "(Lgroovy/lang/MetaClass;)V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn(PUTFIELD, "GroovyInterface$1", "metaClass", "Lgroovy/lang/MetaClass;"); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 2); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC + ACC_SYNTHETIC, "invokeMethod", "(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, "GroovyInterface$1", "getMetaClass", "()Lgroovy/lang/MetaClass;", false); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 2); + mv.visitMethodInsn(INVOKEINTERFACE, "groovy/lang/MetaClass", "invokeMethod", "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;", true); + mv.visitInsn(ARETURN); + mv.visitMaxs(4, 3); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC + ACC_SYNTHETIC, "getProperty", "(Ljava/lang/String;)Ljava/lang/Object;", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, "GroovyInterface$1", "getMetaClass", "()Lgroovy/lang/MetaClass;", false); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitMethodInsn(INVOKEINTERFACE, "groovy/lang/MetaClass", "getProperty", "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;", true); + mv.visitInsn(ARETURN); + mv.visitMaxs(3, 2); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC + ACC_SYNTHETIC, "setProperty", "(Ljava/lang/String;Ljava/lang/Object;)V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKEVIRTUAL, "GroovyInterface$1", "getMetaClass", "()Lgroovy/lang/MetaClass;", false); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 2); + mv.visitMethodInsn(INVOKEINTERFACE, "groovy/lang/MetaClass", "setProperty", "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V", true); + mv.visitInsn(RETURN); + mv.visitMaxs(4, 3); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null); + mv.visitCode(); + mv.visitLdcInsn(Type.getType("LGroovyInterface;")); + mv.visitVarInsn(ASTORE, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(PUTSTATIC, "GroovyInterface$1", "$class$GroovyInterface", "Ljava/lang/Class;"); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(POP); + mv.visitInsn(RETURN); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$createCallSiteArray", "()Lorg/codehaus/groovy/runtime/callsite/CallSiteArray;", null, null); + mv.visitCode(); + mv.visitLdcInsn(new Integer(0)); + mv.visitTypeInsn(ANEWARRAY, "java/lang/String"); + mv.visitVarInsn(ASTORE, 0); + mv.visitTypeInsn(NEW, "org/codehaus/groovy/runtime/callsite/CallSiteArray"); + mv.visitInsn(DUP); + mv.visitLdcInsn(Type.getType("LGroovyInterface$1;")); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, "org/codehaus/groovy/runtime/callsite/CallSiteArray", "<init>", "(Ljava/lang/Class;[Ljava/lang/String;)V", false); + mv.visitInsn(ARETURN); + mv.visitMaxs(4, 1); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC + ACC_SYNTHETIC, "$getCallSiteArray", "()[Lorg/codehaus/groovy/runtime/callsite/CallSite;", null, null); + mv.visitCode(); + mv.visitFieldInsn(GETSTATIC, "GroovyInterface$1", "$callSiteArray", "Ljava/lang/ref/SoftReference;"); + Label l0 = new Label(); + mv.visitJumpInsn(IFNULL, l0); + mv.visitFieldInsn(GETSTATIC, "GroovyInterface$1", "$callSiteArray", "Ljava/lang/ref/SoftReference;"); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/ref/SoftReference", "get", "()Ljava/lang/Object;", false); + mv.visitTypeInsn(CHECKCAST, "org/codehaus/groovy/runtime/callsite/CallSiteArray"); + mv.visitInsn(DUP); + mv.visitVarInsn(ASTORE, 0); + Label l1 = new Label(); + mv.visitJumpInsn(IFNONNULL, l1); + mv.visitLabel(l0); + mv.visitMethodInsn(INVOKESTATIC, "GroovyInterface$1", "$createCallSiteArray", "()Lorg/codehaus/groovy/runtime/callsite/CallSiteArray;", false); + mv.visitVarInsn(ASTORE, 0); + mv.visitTypeInsn(NEW, "java/lang/ref/SoftReference"); + mv.visitInsn(DUP); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/ref/SoftReference", "<init>", "(Ljava/lang/Object;)V", false); + mv.visitFieldInsn(PUTSTATIC, "GroovyInterface$1", "$callSiteArray", "Ljava/lang/ref/SoftReference;"); + mv.visitLabel(l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, "org/codehaus/groovy/runtime/callsite/CallSiteArray", "array", "[Lorg/codehaus/groovy/runtime/callsite/CallSite;"); + mv.visitInsn(ARETURN); + mv.visitMaxs(3, 1); + mv.visitEnd(); + } + cw.visitEnd(); + + return cw.toByteArray(); + } +} diff --git a/test/files/run/t7741a/GroovyInterfaceDump.java b/test/files/run/t7741a/GroovyInterfaceDump.java new file mode 100644 index 0000000000..87c09e272f --- /dev/null +++ b/test/files/run/t7741a/GroovyInterfaceDump.java @@ -0,0 +1,51 @@ +import java.util.*; +import scala.tools.asm.*; + +// generated with +// git clone alewando/scala_groovy_interop +// SCALA_HOME=... GROOVY_HOME=... ant +// cd /code/scala2 +// java -classpath build/asm/classes:/Users/jason/code/scala_groovy_interop/classes:/code/scala2/build/pack/lib/scala-library.jar:/usr/local/Cellar/groovy/2.4.1/libexec/embeddable/groovy-all-2.4.1.jar scala.tools.asm.util.ASMifier 'GroovyInterface$1' +// java -classpath build/asm/classes:/Users/jason/code/scala_groovy_interop/classes:/code/scala2/build/pack/lib/scala-library.jar:/usr/local/Cellar/groovy/2.4.1/libexec/embeddable/groovy-all-2.4.1.jar scala.tools.asm.util.ASMifier 'GroovyInterface$1' +public class GroovyInterfaceDump implements Opcodes { + + public static byte[] dump () throws Exception { + + ClassWriter cw = new ClassWriter(0); + FieldVisitor fv; + MethodVisitor mv; + AnnotationVisitor av0; + + cw.visit(V1_5, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE, "GroovyInterface", null, "java/lang/Object", null); + + cw.visitInnerClass("GroovyInterface$1", "GroovyInterface", "1", ACC_SYNTHETIC); + + cw.visitInnerClass("GroovyInterface$__clinit__closure1", null, null, 0); + + { + fv = cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "closure", "Ljava/lang/Object;", null, null); + fv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null); + mv.visitCode(); + mv.visitTypeInsn(NEW, "GroovyInterface$__clinit__closure1"); + mv.visitInsn(DUP); + mv.visitFieldInsn(GETSTATIC, "GroovyInterface$1", "$class$GroovyInterface", "Ljava/lang/Class;"); + mv.visitFieldInsn(GETSTATIC, "GroovyInterface$1", "$class$GroovyInterface", "Ljava/lang/Class;"); + mv.visitMethodInsn(INVOKESPECIAL, "GroovyInterface$__clinit__closure1", "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V", false); + mv.visitVarInsn(ASTORE, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(PUTSTATIC, "GroovyInterface", "closure", "Ljava/lang/Object;"); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(POP); + mv.visitInsn(RETURN); + mv.visitMaxs(4, 1); + mv.visitEnd(); + } + cw.visitEnd(); + + return cw.toByteArray(); + } +} + diff --git a/test/files/run/t7741a/Test.scala b/test/files/run/t7741a/Test.scala new file mode 100644 index 0000000000..cdba1cccf8 --- /dev/null +++ b/test/files/run/t7741a/Test.scala @@ -0,0 +1,47 @@ +import java.io.{ByteArrayInputStream, FileOutputStream, BufferedOutputStream} +import java.util + +import java.io.File + +import scala.tools.partest.DirectTest + +object Test extends DirectTest { + + def code = "" + + override def show(): Unit = { + + val class1: Array[Byte] = GroovyInterfaceDump.dump() + val class2: Array[Byte] = GroovyInterface$1Dump.dump() + def writeFile(contents: Array[Byte], f: java.io.File): Unit = { + val out = new BufferedOutputStream(new FileOutputStream(f)) + try { + out.write(contents) + } finally out.close() + } + + val outdir = testOutput.jfile + + // interface GroovyInterface { + // + // // This is the line that causes scalac to choke. + // // It results in a GroovyInterface$1 class, which is a non-static inner class but its constructor does not + // // include the implicit parameter that is the immediate enclosing instance. + // // See http://jira.codehaus.org/browse/GROOVY-7312 + // // + // // Scalac error: + // // [scalac] error: error while loading 1, class file '..../scala_groovy_interop/classes/com/example/groovy/GroovyInterface$1.class' is broken + // // [scalac] (class java.util.NoSuchElementException/head of empty list) + // final static def closure = { x -> "banana" } + // + // } + writeFile(GroovyInterfaceDump.dump(), new File(outdir, "GroovyInterface.class")) + writeFile(GroovyInterface$1Dump.dump(), new File(outdir, "GroovyInterface$1.class")) + compileCode("object Test { def foo(g: GroovyInterface) = g.toString }") + } + + def compileCode(code: String) = { + val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") + compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code) + } +} diff --git a/test/files/run/t7741b.check b/test/files/run/t7741b.check new file mode 100644 index 0000000000..a19e54aa3a --- /dev/null +++ b/test/files/run/t7741b.check @@ -0,0 +1,3 @@ +1. Don't refer to Inner +2. Refering to Inner +pos: NoPosition Class file for HasInner$Inner not found ERROR diff --git a/test/files/run/t7741b/HasInner.java b/test/files/run/t7741b/HasInner.java new file mode 100644 index 0000000000..a1d0d0d81a --- /dev/null +++ b/test/files/run/t7741b/HasInner.java @@ -0,0 +1,3 @@ +class HasInner { + class Inner {} +} diff --git a/test/files/run/t7741b/Test.scala b/test/files/run/t7741b/Test.scala new file mode 100644 index 0000000000..569ae6b679 --- /dev/null +++ b/test/files/run/t7741b/Test.scala @@ -0,0 +1,29 @@ +import java.io.File + +import scala.tools.partest.StoreReporterDirectTest + +object Test extends StoreReporterDirectTest { + + def code = "" + + override def show(): Unit = { + deleteClass("HasInner$Inner") + println("1. Don't refer to Inner") + compileCode("class Test { def test(x: HasInner) = x }") + assert(filteredInfos.isEmpty, filteredInfos) + println("2. Refering to Inner") + compileCode("class Test { def test(x: HasInner#Inner) = x }") + println(filteredInfos.mkString("\n")) + } + + def deleteClass(name: String) { + val classFile = new File(testOutput.path, name + ".class") + assert(classFile.exists) + assert(classFile.delete()) + } + + def compileCode(code: String) = { + val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") + compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code) + } +} diff --git a/test/files/run/t7747-repl.check b/test/files/run/t7747-repl.check index ad924f482c..105b238d01 100644 --- a/test/files/run/t7747-repl.check +++ b/test/files/run/t7747-repl.check @@ -283,4 +283,4 @@ object $read extends $read { } res3: List[Product with Serializable] = List(BippyBups(), PuppyPups(), Bingo()) -scala> +scala> :quit diff --git a/test/files/run/t7801.check b/test/files/run/t7801.check index d72060c684..e0b656b784 100644 --- a/test/files/run/t7801.check +++ b/test/files/run/t7801.check @@ -8,4 +8,4 @@ import g.abort scala> class C(val a: Any) extends AnyVal defined class C -scala> +scala> :quit diff --git a/test/files/run/t7805-repl-i.check b/test/files/run/t7805-repl-i.check index eecfff079a..7f66c06a11 100644 --- a/test/files/run/t7805-repl-i.check +++ b/test/files/run/t7805-repl-i.check @@ -8,4 +8,4 @@ Type :help for more information. scala> Console println Try(8) Success(8) -scala> +scala> :quit diff --git a/test/files/run/t7852.scala b/test/files/run/t7852.scala index c93db718fd..1679067510 100644 --- a/test/files/run/t7852.scala +++ b/test/files/run/t7852.scala @@ -12,7 +12,7 @@ object Test extends BytecodeTest { val classNode = loadClassNode("Lean") val methodNode = getMethod(classNode, methodName) val got = countNullChecks(methodNode.instructions) - assert(got == expected, s"expected $expected but got $got comparisons") + assert(got == expected, s"$methodName: expected $expected but got $got comparisons") } test("string", expected = 0) test("module", expected = 0) diff --git a/test/files/run/t7932.check b/test/files/run/t7932.check index 13d64f1d3c..3f0a0c4f62 100644 --- a/test/files/run/t7932.check +++ b/test/files/run/t7932.check @@ -1,3 +1,3 @@ -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details public Category<?> C.category() public Category<scala.Tuple2> C.category1() diff --git a/test/files/run/t7965.scala b/test/files/run/t7965.scala new file mode 100644 index 0000000000..df80d4b5bb --- /dev/null +++ b/test/files/run/t7965.scala @@ -0,0 +1,54 @@ +// Test that scala doesn't apply boxing or varargs conversions to the +// @PolymorphicSignature magical methods, MethodHandle#{invoke, invokeExact} +object Test { + val code = """ + +object O { + private def foo = "foo" + private def bar(x: Int): Int = -x + private def baz(x: Box): Unit = x.a = "present" + val lookup = java.lang.invoke.MethodHandles.lookup +} + +import java.lang.invoke._ +class Box(var a: Any) + +object Test { + def main(args: Array[String]): Unit = { + def lookup(name: String, params: Array[Class[_]], ret: Class[_]) = { + val mt = MethodType.methodType(ret, params) + O.lookup.findVirtual(O.getClass, name, mt) + } + val fooResult = (lookup("foo", Array(), classOf[String]).invokeExact(O): Int) + assert(fooResult == "foo") + + val barResult = (lookup("bar", Array(classOf[Int]), classOf[Int]).invokeExact(O, 42): Int) + assert(barResult == -42) + + val box = new Box(null) + (lookup("baz", Array(classOf[Box]), Void.TYPE).invokeExact(O, box) : Unit) + assert(box.a == "present") + + // Note: Application in statement position in a block in Java also infers return type of Unit, + // but we don't support that, ascribe the type to Unit as above. + // as done in Java. + // lookup("baz", Array(classOf[Box]), Void.TYPE).invokeExact(O, box) + () + } +} + +""" + def main(args: Array[String]): Unit = { + if (util.Properties.isJavaAtLeast("1.7")) test() + } + + def test() { + import scala.reflect.runtime._ + import scala.tools.reflect.ToolBox + + val m = currentMirror + val tb = m.mkToolBox() + import tb._ + eval(parse(code)) + } +} diff --git a/test/files/run/t7974.check b/test/files/run/t7974.check index 0be496d8d0..4eae5eb152 100644 --- a/test/files/run/t7974.check +++ b/test/files/run/t7974.check @@ -1,37 +1,14 @@ -public class Symbols { - - // compiled from: Symbols.scala - - - - // access flags 0x12 - private final Lscala/Symbol; someSymbol3 - - // access flags 0xA - private static Lscala/Symbol; symbol$1 - - // access flags 0xA - private static Lscala/Symbol; symbol$2 - - // access flags 0xA - private static Lscala/Symbol; symbol$3 // access flags 0x9 public static <clinit>()V - L0 - LINENUMBER 2 L0 GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$; LDC "Symbolic1" INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol; PUTSTATIC Symbols.symbol$1 : Lscala/Symbol; - L1 - LINENUMBER 3 L1 GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$; LDC "Symbolic2" INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol; PUTSTATIC Symbols.symbol$2 : Lscala/Symbol; - L2 - LINENUMBER 5 L2 GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$; LDC "Symbolic3" INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol; @@ -40,65 +17,48 @@ public class Symbols { MAXSTACK = 2 MAXLOCALS = 0 + // access flags 0x1 public someSymbol1()Lscala/Symbol; - L0 - LINENUMBER 2 L0 GETSTATIC Symbols.symbol$1 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 + // access flags 0x1 public someSymbol2()Lscala/Symbol; - L0 - LINENUMBER 3 L0 GETSTATIC Symbols.symbol$2 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 + // access flags 0x1 public sameSymbol1()Lscala/Symbol; - L0 - LINENUMBER 4 L0 GETSTATIC Symbols.symbol$1 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 + // access flags 0x1 public someSymbol3()Lscala/Symbol; - L0 - LINENUMBER 5 L0 ALOAD 0 GETFIELD Symbols.someSymbol3 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 + // access flags 0x1 public <init>()V - L0 - LINENUMBER 6 L0 ALOAD 0 INVOKESPECIAL java/lang/Object.<init> ()V - L1 - LINENUMBER 5 L1 ALOAD 0 GETSTATIC Symbols.symbol$3 : Lscala/Symbol; PUTFIELD Symbols.someSymbol3 : Lscala/Symbol; RETURN - L2 - LOCALVARIABLE this LSymbols; L0 L2 0 MAXSTACK = 2 MAXLOCALS = 1 -} + diff --git a/test/files/run/t7974.flags b/test/files/run/t7974.flags new file mode 100644 index 0000000000..5fc2a03894 --- /dev/null +++ b/test/files/run/t7974.flags @@ -0,0 +1 @@ +-Xcheckinit:false diff --git a/test/files/run/t7974/Test.scala b/test/files/run/t7974/Test.scala index 9403ea332b..296ec32ee2 100644 --- a/test/files/run/t7974/Test.scala +++ b/test/files/run/t7974/Test.scala @@ -1,20 +1,14 @@ -import java.io.PrintWriter; +import java.io.PrintWriter import scala.tools.partest.BytecodeTest +import scala.tools.nsc.backend.jvm.AsmUtils import scala.tools.asm.util._ import scala.tools.nsc.util.stringFromWriter +import scala.collection.convert.decorateAsScala._ object Test extends BytecodeTest { def show { - val classNode = loadClassNode("Symbols", skipDebugInfo = false) - val textifier = new Textifier - classNode.accept(new TraceClassVisitor(null, textifier, null)) - - val classString = stringFromWriter(w => textifier.print(w)) - val result = - classString.split('\n') - .dropWhile(elem => elem != "public class Symbols {") - .filterNot(elem => elem.startsWith(" @Lscala/reflect/ScalaSignature") || elem.startsWith(" ATTRIBUTE ScalaSig")) - result foreach println + val classNode = loadClassNode("Symbols", skipDebugInfo = true) + classNode.methods.asScala.foreach(m => println(AsmUtils.textify(m))) } } diff --git a/test/files/run/t7992.scala b/test/files/run/t7992.scala new file mode 100644 index 0000000000..fde231b961 --- /dev/null +++ b/test/files/run/t7992.scala @@ -0,0 +1,20 @@ +class C { + def foo: Int = 0 +} + +class D extends C { + override def foo: Int = { + val f = () => { + class C // comment this line to fix. + D.super.foo // no super accessor generated here! + // java.lang.VerifyError: (class: D$$anonfun$1, method: apply$mcI$sp signature: ()I) Illegal use of nonvirtual function call + } + f() + } +} + +object Test { + def main(args: Array[String]) { + new D().foo + } +} diff --git a/test/files/run/t7992b.scala b/test/files/run/t7992b.scala new file mode 100644 index 0000000000..6fe1f990d5 --- /dev/null +++ b/test/files/run/t7992b.scala @@ -0,0 +1,18 @@ +class C { + def foo: Int = 0 +} + +class E extends C { + override def foo: Int = { + (None: Option[Int]).getOrElse { + class C + E.super.foo + } + } +} + +object Test { + def main(args: Array[String]) { + new E().foo + } +} diff --git a/test/files/run/t8087.scala b/test/files/run/t8087.scala new file mode 100644 index 0000000000..6047211756 --- /dev/null +++ b/test/files/run/t8087.scala @@ -0,0 +1,12 @@ +trait Foo { + @volatile private[this] var x: String = "" + @volatile private var y: String = "" +} + +class Bar extends Foo + +object Test extends App { + classOf[Bar].getDeclaredFields.foreach(f => { + assert(java.lang.reflect.Modifier.isVolatile(f.getModifiers), f.getName) + }) +} diff --git a/test/files/run/t8196.check b/test/files/run/t8196.check new file mode 100644 index 0000000000..d11dc27e68 --- /dev/null +++ b/test/files/run/t8196.check @@ -0,0 +1,7 @@ +t8196.scala:26: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses + form2.g1 // comment this line in order to make the test pass + ^ +warning: there were two feature warnings; re-run with -feature for details +Scope{ + final private val f1: Int +} diff --git a/test/files/run/t8196.scala b/test/files/run/t8196.scala new file mode 100644 index 0000000000..e219ac166b --- /dev/null +++ b/test/files/run/t8196.scala @@ -0,0 +1,51 @@ +import scala.reflect.runtime.{ universe => ru } + +object Test extends App { + + trait FormTrait { + + val runtimeMirror = ru.runtimeMirror(this.getClass.getClassLoader) + val instanceMirror = runtimeMirror.reflect(this) + val members = instanceMirror.symbol.typeSignature.members + def fields = members.filter(_.typeSignature <:< ru.typeOf[Int]) + } + + val f = () => { + + class Form1 extends FormTrait { + val f1 = 5 + } + val form1 = new Form1 + + println(form1.fields) + + val form2 = new FormTrait { + val g1 = new Form1 + } + + form2.g1 // comment this line in order to make the test pass + () + } + + val g = () => { + // Reported as SI-8195, same root cause + trait Form { + + private val runtimeMirror = ru.runtimeMirror(this.getClass.getClassLoader) + private val instanceMirror = runtimeMirror.reflect(this) + private val members = instanceMirror.symbol.typeSignature.members + + } + + val f1 = new Form { + val a = 1 + } + + val f2 = new Form { + val b = f1.a + } + } + + f() + g() +} diff --git a/test/files/run/t8253.check b/test/files/run/t8253.check new file mode 100644 index 0000000000..0b4cb2d1f7 --- /dev/null +++ b/test/files/run/t8253.check @@ -0,0 +1,40 @@ + +<sample xmlns='ns1'/> +{ + var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope; + $tmpscope = new _root_.scala.xml.NamespaceBinding(null, "ns1", $tmpscope); + { + val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope; + new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true) + } +} + +<sample xmlns={identity(ns1)}/> +{ + var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope; + $tmpscope = new _root_.scala.xml.NamespaceBinding(null, ns1, $tmpscope); + { + val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope; + new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true) + } +} + +<sample xmlns:foo='ns1'/> +{ + var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope; + $tmpscope = new _root_.scala.xml.NamespaceBinding("foo", "ns1", $tmpscope); + { + val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope; + new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true) + } +} + +<sample xmlns:foo={identity(ns1)}/> +{ + var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope; + $tmpscope = new _root_.scala.xml.NamespaceBinding("foo", ns1, $tmpscope); + { + val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope; + new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true) + } +} diff --git a/test/files/run/t8253.scala b/test/files/run/t8253.scala new file mode 100644 index 0000000000..a00d8b91a4 --- /dev/null +++ b/test/files/run/t8253.scala @@ -0,0 +1,14 @@ +object Test extends App { + import reflect.runtime.universe._ // not using the XML library in compiler tests + + def show(code: String, t: Tree) = println(s"\n$code\n$t") + + val ns1 = "ns1" + show("<sample xmlns='ns1'/>", q"<sample xmlns='ns1'/>") + show("<sample xmlns={identity(ns1)}/>", q"<sample xmlns={ns1}/>") + show("<sample xmlns:foo='ns1'/>", q"<sample xmlns:foo='ns1'/>") + show("<sample xmlns:foo={identity(ns1)}/>", q"<sample xmlns:foo={ns1}/>") + + // `identity(foo)` used to match the overly permissive match in SymbolXMLBuilder + // which was intended to more specifically match `_root_.scala.xml.Text(...)` +} diff --git a/test/files/run/t8346.check b/test/files/run/t8346.check new file mode 100644 index 0000000000..1ba5c31abe --- /dev/null +++ b/test/files/run/t8346.check @@ -0,0 +1,6 @@ +BitSet: List(invariant, invariant, invariant, invariant) +HashSet: List(covariant (true), covariant (true), covariant (true), covariant (true)) +ListSet: List(covariant (true), covariant (true), covariant (true), covariant (true)) +SortedSet: List(invariant, invariant, invariant, invariant) +TreeSet: List(invariant, invariant, invariant, invariant) +ValueSet: invariant diff --git a/test/files/run/t8346.scala b/test/files/run/t8346.scala new file mode 100644 index 0000000000..5f3df84174 --- /dev/null +++ b/test/files/run/t8346.scala @@ -0,0 +1,34 @@ +object Test extends App { + import reflect.ClassTag + + object SomeEnum extends Enumeration { + val one, two, three, four = Value + } + + def sctor[A <: Set[Int]](f: Int => A)(implicit A: ClassTag[A]) + : (String, Int => Set[Int]) = + (A.runtimeClass.getSimpleName, f) + + val inits: Seq[(String, Int => Set[Int])] = { + import collection.immutable.{Seq => _, _} + Seq(sctor(BitSet(_)), + sctor(HashSet(_)), + sctor(ListSet(_)), + sctor(SortedSet(_)), + sctor(TreeSet(_))) + } + + def sVarInfo[A](sa: Set[A]): String = { + val saa = sa.toSet[Any] + if (sa eq saa) s"""covariant (${(saa + "hi") contains "hi"})""" + else "invariant" + } + + inits foreach {case (name, singleton) => + print(s"${name}: ") + val one = singleton(1) + println(Seq(2,3,4).scanLeft(one)(_ + _) map sVarInfo toList) + } + + println(s"ValueSet: ${sVarInfo(SomeEnum.values)}") +} diff --git a/test/files/run/t8442.check b/test/files/run/t8442.check new file mode 100644 index 0000000000..ce9e8b52ff --- /dev/null +++ b/test/files/run/t8442.check @@ -0,0 +1 @@ +pos: NoPosition Class A_1 not found - continuing with a stub. WARNING diff --git a/test/files/run/t8442/A_1.java b/test/files/run/t8442/A_1.java new file mode 100644 index 0000000000..227451eecd --- /dev/null +++ b/test/files/run/t8442/A_1.java @@ -0,0 +1,4 @@ +@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME) +public @interface A_1 { + +}
\ No newline at end of file diff --git a/test/files/run/t8442/B_1.java b/test/files/run/t8442/B_1.java new file mode 100644 index 0000000000..1680684495 --- /dev/null +++ b/test/files/run/t8442/B_1.java @@ -0,0 +1,3 @@ +public class B_1 { + @A_1 public String get() { return ""; } +} diff --git a/test/files/run/t8442/C_2.scala b/test/files/run/t8442/C_2.scala new file mode 100644 index 0000000000..d75d4bd910 --- /dev/null +++ b/test/files/run/t8442/C_2.scala @@ -0,0 +1,5 @@ +class C_2 { + def foo(b: B_1) { + b.get() + } +} diff --git a/test/files/run/t8442/Test.scala b/test/files/run/t8442/Test.scala new file mode 100644 index 0000000000..ff6da4e206 --- /dev/null +++ b/test/files/run/t8442/Test.scala @@ -0,0 +1,29 @@ +import scala.tools.partest._ +import java.io.File + +object Test extends StoreReporterDirectTest { + def code = ??? + + def compileCode(code: String) = { + val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") + compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code) + } + + def app = """ + class C_2 { + def foo(b: B_1) { + b.get() + } + } + """ + + def show(): Unit = { + val tClass = new File(testOutput.path, "A_1.class") + assert(tClass.exists) + assert(tClass.delete()) + + // Expecting stub symbol warning, but no stack trace! + compileCode(app) + println(filteredInfos.mkString("\n")) + } +} diff --git a/test/files/run/t8445.check b/test/files/run/t8445.check new file mode 100644 index 0000000000..41fd6d3ed1 --- /dev/null +++ b/test/files/run/t8445.check @@ -0,0 +1 @@ +warning: there was one feature warning; re-run with -feature for details diff --git a/test/files/run/t8445.scala b/test/files/run/t8445.scala new file mode 100644 index 0000000000..ed196b62a2 --- /dev/null +++ b/test/files/run/t8445.scala @@ -0,0 +1,11 @@ +object X { + class Y + def y = new Y { + class Z + def z = classOf[Z] + } +} + +object Test extends App { + assert(X.y.z.getEnclosingClass.getName == "X$$anon$1") +} diff --git a/test/files/run/t8502.scala b/test/files/run/t8502.scala new file mode 100644 index 0000000000..903e573711 --- /dev/null +++ b/test/files/run/t8502.scala @@ -0,0 +1,41 @@ +import scala.tools.partest._ +import java.io.File + +object Test extends StoreReporterDirectTest { + def code = ??? + + def compileCode(code: String) = { + val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") + compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code) + } + + def show(): Unit = { + compileCode(""" + object U { + def foo(log: vanishing.Vanishing) = () + } + + package vanishing { + class Vanishing + } + """) + assert(filteredInfos.isEmpty, filteredInfos) + deletePackage("vanishing") + compileCode(""" + class Test { + U + } + """) + assert(storeReporter.infos.isEmpty, storeReporter.infos.mkString("\n")) // Included a MissingRequirementError before. + } + + def deletePackage(name: String) { + val directory = new File(testOutput.path, name) + for (f <- directory.listFiles()) { + assert(f.getName.endsWith(".class")) + assert(f.delete()) + } + assert(directory.listFiles().isEmpty) + assert(directory.delete()) + } +} diff --git a/test/files/run/t8549.check b/test/files/run/t8549.check new file mode 100644 index 0000000000..a9ecc29fea --- /dev/null +++ b/test/files/run/t8549.check @@ -0,0 +1 @@ +warning: there were two deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t8549.scala b/test/files/run/t8549.scala new file mode 100644 index 0000000000..cb254e3810 --- /dev/null +++ b/test/files/run/t8549.scala @@ -0,0 +1,189 @@ +import javax.xml.bind.DatatypeConverter._ +import scala.reflect.io.File + +// This test is self-modifying when run as follows: +// +// (export V=v2.10.4 +// scalac-hash $V test/files/run/t8549.scala +// scala-hash $V -Doverwrite.source=test/files/run/t8549.scala Test +// ) +// +// Use this to re-establish a baseline for serialization compatibility. +object Test extends App { + val overwrite: Option[File] = sys.props.get("overwrite.source").map(s => new File(new java.io.File(s))) + + def serialize(o: AnyRef): String = { + val bos = new java.io.ByteArrayOutputStream() + val out = new java.io.ObjectOutputStream(bos) + out.writeObject(o) + out.flush() + printBase64Binary(bos.toByteArray()) + } + + def amend(file: File)(f: String => String) { + file.writeAll(f(file.slurp)) + } + def quote(s: String) = List("\"", s, "\"").mkString + + def patch(file: File, line: Int, prevResult: String, result: String) { + amend(file) { + content => + content.lines.toList.zipWithIndex.map { + case (content, i) if i == line - 1 => + val newContent = content.replaceAllLiterally(quote(prevResult), quote(result)) + if (newContent != content) + println(s"- $content\n+ $newContent\n") + newContent + case (content, _) => content + }.mkString("\n") + } + } + + def updateComment(file: File) { + val timestamp = { + import java.text.SimpleDateFormat + val sdf = new SimpleDateFormat("yyyyMMdd-HH:mm:ss") + sdf.format(new java.util.Date) + } + val newComment = s" // Generated on $timestamp with Scala ${scala.util.Properties.versionString})" + amend(file) { + content => + content.lines.toList.map { + f => f.replaceAll("""^ +// Generated on.*""", newComment) + }.mkString("\n") + } + } + + def deserialize(string: String): AnyRef = { + val bis = new java.io.ByteArrayInputStream(parseBase64Binary(string)) + val in = new java.io.ObjectInputStream(bis) + in.readObject() + } + + def checkRoundTrip[T <: AnyRef](instance: T)(f: T => AnyRef) { + val result = serialize(instance) + val reconstituted = deserialize(result).asInstanceOf[T] + assert(f(instance) == f(reconstituted), (f(instance), f(reconstituted))) + } + + def check[T <: AnyRef](instance: => T)(prevResult: String, f: T => AnyRef = (x: T) => x) { + val result = serialize(instance) + overwrite match { + case Some(f) => + val lineNumberOfLiteralString = Thread.currentThread.getStackTrace.apply(2).getLineNumber + patch(f, lineNumberOfLiteralString, prevResult, result) + case None => + checkRoundTrip(instance)(f) + assert(f(deserialize(prevResult).asInstanceOf[T]) == f(instance), s"$instance != f(deserialize(prevResult))") + assert(prevResult == result, s"instance = $instance : ${instance.getClass}\n serialization unstable: ${prevResult}\n found: ${result}") + } + } + + // Generated on 20141010-14:01:28 with Scala version 2.11.2) + overwrite.foreach(updateComment) + + check(Some(1))("rO0ABXNyAApzY2FsYS5Tb21lESLyaV6hi3QCAAFMAAF4dAASTGphdmEvbGFuZy9PYmplY3Q7eHIADHNjYWxhLk9wdGlvbv5pN/3bDmZ0AgAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAQ==") + check(None)("rO0ABXNyAAtzY2FsYS5Ob25lJEZQJPZTypSsAgAAeHIADHNjYWxhLk9wdGlvbv5pN/3bDmZ0AgAAeHA=") + + check(List(1, 2, 3))( "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHg=") + check(Nil)( "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdFNlcmlhbGl6ZUVuZCSKXGNb91MLbQIAAHhweA==") + + // TODO SI-8576 unstable under -Xcheckinit + // check(Vector(1))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAABAAAAAAEAAAAAAAAAAHVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAACBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcA==") + // check(Vector())( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAAAAAAAAAAAAAAAAAAAAHBwcHBwcA==") + + import collection.{ mutable, immutable } + + class C + check(reflect.classTag[C])("rO0ABXNyAB5zY2FsYS5yZWZsZWN0LkNsYXNzVGFnJCRhbm9uJDG7ePPrmQBkhgIAAUwAD3J1bnRpbWVDbGFzczEkMXQAEUxqYXZhL2xhbmcvQ2xhc3M7eHB2cgAGVGVzdCRDAAAAAAAAAAAAAAB4cA==") + check(reflect.classTag[Int])("rO0ABXNyACVzY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSQkYW5vbiQ5zfmiSVNjtVICAAB4cgAcc2NhbGEucmVmbGVjdC5BbnlWYWxNYW5pZmVzdAAAAAAAAAABAgABTAAIdG9TdHJpbmd0ABJMamF2YS9sYW5nL1N0cmluZzt4cHQAA0ludA==") + check(reflect.classTag[String])("rO0ABXNyAB5zY2FsYS5yZWZsZWN0LkNsYXNzVGFnJCRhbm9uJDG7ePPrmQBkhgIAAUwAD3J1bnRpbWVDbGFzczEkMXQAEUxqYXZhL2xhbmcvQ2xhc3M7eHB2cgAQamF2YS5sYW5nLlN0cmluZ6DwpDh6O7NCAgAAeHA=") + check(reflect.classTag[Object])("rO0ABXNyACVzY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSQkYW5vbiQymPrtq/Ci1gsCAAB4cgAtc2NhbGEucmVmbGVjdC5NYW5pZmVzdEZhY3RvcnkkUGhhbnRvbU1hbmlmZXN0rzigP7KRh/kCAAFMAAh0b1N0cmluZ3QAEkxqYXZhL2xhbmcvU3RyaW5nO3hyAC9zY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSRDbGFzc1R5cGVNYW5pZmVzdFq6NWvfTgYFAgADTAAGcHJlZml4dAAOTHNjYWxhL09wdGlvbjtMAAxydW50aW1lQ2xhc3N0ABFMamF2YS9sYW5nL0NsYXNzO0wADXR5cGVBcmd1bWVudHN0ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDt4cHNyAAtzY2FsYS5Ob25lJEZQJPZTypSsAgAAeHIADHNjYWxhLk9wdGlvbv5pN/3bDmZ0AgAAeHB2cgAQamF2YS5sYW5nLk9iamVjdAAAAAAAAAAAAAAAeHBzcgAyc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAQMAAHhwc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHh0AAZPYmplY3Q=") + + // TODO SI-8576 unstable under -Xcheckinit + // check(Enum)( "rO0ABXNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAHeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ACXcNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqc3IAFXNjYWxhLkVudW1lcmF0aW9uJFZhbM9pZ6/J/O1PAgACSQAYc2NhbGEkRW51bWVyYXRpb24kVmFsJCRpTAAEbmFtZXQAEkxqYXZhL2xhbmcvU3RyaW5nO3hyABdzY2FsYS5FbnVtZXJhdGlvbiRWYWx1ZWJpfC/tIR1RAgACTAAGJG91dGVydAATTHNjYWxhL0VudW1lcmF0aW9uO0wAHHNjYWxhJEVudW1lcmF0aW9uJCRvdXRlckVudW1xAH4AEnhwcQB+AAhxAH4ACAAAACpweHNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHEAfgARcQB+AAhxAH4ACHEAfgAT") + // check(Enum.V1)( "rO0ABXNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHIAF3NjYWxhLkVudW1lcmF0aW9uJFZhbHVlYml8L+0hHVECAAJMAAYkb3V0ZXJ0ABNMc2NhbGEvRW51bWVyYXRpb247TAAcc2NhbGEkRW51bWVyYXRpb24kJG91dGVyRW51bXEAfgACeHBzcgAKVGVzdCRFbnVtJHrQiMkPAttzAgACTAACVjF0ABlMc2NhbGEvRW51bWVyYXRpb24kVmFsdWU7TAACVjJ0ABdMc2NhbGEvRW51bWVyYXRpb24kVmFsO3hyABFzY2FsYS5FbnVtZXJhdGlvbnWgzd2YDlmOAgAISQAGbmV4dElkSQAbc2NhbGEkRW51bWVyYXRpb24kJGJvdHRvbUlkSQAYc2NhbGEkRW51bWVyYXRpb24kJHRvcElkTAAUVmFsdWVPcmRlcmluZyRtb2R1bGV0ACJMc2NhbGEvRW51bWVyYXRpb24kVmFsdWVPcmRlcmluZyQ7TAAPVmFsdWVTZXQkbW9kdWxldAAdTHNjYWxhL0VudW1lcmF0aW9uJFZhbHVlU2V0JDtMAAhuZXh0TmFtZXQAG0xzY2FsYS9jb2xsZWN0aW9uL0l0ZXJhdG9yO0wAF3NjYWxhJEVudW1lcmF0aW9uJCRubWFwdAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9NYXA7TAAXc2NhbGEkRW51bWVyYXRpb24kJHZtYXBxAH4AC3hwAAAAKwAAAAAAAAArcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5IYXNoTWFwAAAAAAAAAAEDAAB4cHcNAAAC7gAAAAAAAAAEAHhzcQB+AA13DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAKnNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cQB+AAFxAH4ADHEAfgAMAAAAKnB4cQB+AANxAH4AFXEAfgAM") + // check(Enum.V2)( "rO0ABXNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cgAXc2NhbGEuRW51bWVyYXRpb24kVmFsdWViaXwv7SEdUQIAAkwABiRvdXRlcnQAE0xzY2FsYS9FbnVtZXJhdGlvbjtMABxzY2FsYSRFbnVtZXJhdGlvbiQkb3V0ZXJFbnVtcQB+AAN4cHNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAMeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ADncNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqcQB+AAR4c3IAEVRlc3QkRW51bSQkYW5vbiQxWUiOWYTWxdoCAAB4cQB+AAJxAH4ADXEAfgANcQB+AARxAH4ADQAAACpw") + + // IndexedSeqLike#Elements + // TODO SI-8576 throws scala.UnitializedFieldError under -Xcheckinit + // check(new immutable.Range(0, 1, 1).iterator)("rO0ABXNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAQAAAABzcgAgc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmFuZ2Vpu6NUqxUyDQIAB0kAA2VuZFoAB2lzRW1wdHlJAAtsYXN0RWxlbWVudEkAEG51bVJhbmdlRWxlbWVudHNJAAVzdGFydEkABHN0ZXBJAA90ZXJtaW5hbEVsZW1lbnR4cAAAAAEAAAAAAAAAAAEAAAAAAAAAAQAAAAE=" + // , _.toList) + + // check(new collection.concurrent.TrieMap[Any, Any]())( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmNvbmN1cnJlbnQuVHJpZU1hcKckxpgOIYHPAwAETAALZXF1YWxpdHlvYmp0ABJMc2NhbGEvbWF0aC9FcXVpdjtMAApoYXNoaW5nb2JqdAAcTHNjYWxhL3V0aWwvaGFzaGluZy9IYXNoaW5nO0wABHJvb3R0ABJMamF2YS9sYW5nL09iamVjdDtMAAtyb290dXBkYXRlcnQAOUxqYXZhL3V0aWwvY29uY3VycmVudC9hdG9taWMvQXRvbWljUmVmZXJlbmNlRmllbGRVcGRhdGVyO3hwc3IAMnNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwJE1hbmdsZWRIYXNoaW5nhTBoJQ/mgb0CAAB4cHNyABhzY2FsYS5tYXRoLkVxdWl2JCRhbm9uJDLBbyx4dy/qGwIAAHhwc3IANHNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwU2VyaWFsaXphdGlvbkVuZCSbjdgbbGCt2gIAAHhweA==") + // not sure why this one needs stable serialization. + + // TODO SI-8576 unstable under -Xcheckinit + check(collection.convert.Wrappers)( "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") + + check(immutable.BitSet(1, 2, 3))( "rO0ABXNyAClzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5CaXRTZXQkQml0U2V0MR9dg8JGRI8UAgABSgAFZWxlbXN4cgAhc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuQml0U2V0Flz5Ms3qxsoCAAB4cAAAAAAAAAAO") + check(immutable.HashMap())( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoTWFwJFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAB4") + check(immutable.HashMap(1 -> 2))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoTWFwJFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJ4") + check(immutable.HashMap(1 -> 2, 3 -> 4))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoTWFwJFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAJzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADc3EAfgACAAAABHg=") + // TODO provoke HashMapCollision1 + + check(immutable.HashSet())( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAB4") + check(immutable.HashSet(1))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXg=") + check(immutable.HashSet(1, 2))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAJzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJ4") + check(immutable.HashSet(1, 2, 3))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") + // TODO provoke HashSetCollision1 + + check(immutable.ListMap())( "rO0ABXNyADBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0TWFwJEVtcHR5TGlzdE1hcCSNalsvpBZeDgIAAHhyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0TWFwBC1gfIkUSKsCAAB4cA==") + check(immutable.ListMap(1 -> 2))( "rO0ABXNyACdzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0TWFwJE5vZGWmciM1Yav+8gIAA0wABiRvdXRlcnQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9MaXN0TWFwO0wAA2tleXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABXZhbHVlcQB+AAJ4cgAic2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdE1hcAQtYHyJFEirAgAAeHBzcgAwc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdE1hcCRFbXB0eUxpc3RNYXAkjWpbL6QWXg4CAAB4cQB+AANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABwAAAAI=") + check(immutable.Queue())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5RdWV1ZZY146W3qSuhAgACTAACaW50ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDtMAANvdXRxAH4AAXhwc3IAMnNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3QkU2VyaWFsaXphdGlvblByb3h5AAAAAAAAAAEDAAB4cHNyACxzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0U2VyaWFsaXplRW5kJIpcY1v3UwttAgAAeHB4cQB+AAQ=") + check(immutable.Queue(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5RdWV1ZZY146W3qSuhAgACTAACaW50ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDtMAANvdXRxAH4AAXhwc3IAMnNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3QkU2VyaWFsaXphdGlvblByb3h5AAAAAAAAAAEDAAB4cHNyACxzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0U2VyaWFsaXplRW5kJIpcY1v3UwttAgAAeHB4c3EAfgADc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAgAAAACc3EAfgAIAAAAA3EAfgAGeA==") + + // TODO SI-8576 throws scala.UnitializedFieldError under -Xcheckinit + // check(new immutable.Range(0, 1, 1))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SYW5nZWm7o1SrFTINAgAHSQADZW5kWgAHaXNFbXB0eUkAC2xhc3RFbGVtZW50SQAQbnVtUmFuZ2VFbGVtZW50c0kABXN0YXJ0SQAEc3RlcEkAD3Rlcm1pbmFsRWxlbWVudHhwAAAAAQAAAAAAAAAAAQAAAAAAAAABAAAAAQ==") + + check(immutable.Set())( "rO0ABXNyAChzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkRW1wdHlTZXQk8Hk3TFN0uDYCAAB4cA==") + check(immutable.Set(1))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0MREd3c4yqtWTAgABTAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDt4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAB") + check(immutable.Set(1, 2))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0MqaV02sZQzV0AgACTAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDtMAAVlbGVtMnEAfgABeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAwAAAAI=") + check(immutable.Set(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0M84syT0560SgAgADTAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDtMAAVlbGVtMnEAfgABTAAFZWxlbTNxAH4AAXhwc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAMAAAACc3EAfgADAAAAAw==") + check(immutable.Set(1, 2, 3, 4))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0NM26psRRbei1AgAETAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDtMAAVlbGVtMnEAfgABTAAFZWxlbTNxAH4AAUwABWVsZW00cQB+AAF4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgADAAAAAnNxAH4AAwAAAANzcQB+AAMAAAAE") + check(immutable.Set(1, 2, 3, 4, 5))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAVzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAABXNxAH4AAgAAAAFzcQB+AAIAAAACc3EAfgACAAAAA3NxAH4AAgAAAAR4") + + check(immutable.Stack(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdGFjaxtt3qEbMvq+AgABTAAFZWxlbXN0ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDt4cHNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABQAAAAJzcQB+AAUAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHg=") + + // TODO SI-8576 Uninitialized field: IndexedSeqLike.scala: 56 + // check(immutable.Stream(1, 2, 3))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0kQ29uc/ekjBXM3TlFAgADTAACaGR0ABJMamF2YS9sYW5nL09iamVjdDtMAAV0bEdlbnQAEUxzY2FsYS9GdW5jdGlvbjA7TAAFdGxWYWx0ACNMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvU3RyZWFtO3hyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0552RDntM42gIAAHhwc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcgAtc2NhbGEuY29sbGVjdGlvbi5JdGVyYXRvciQkYW5vbmZ1biR0b1N0cmVhbSQxRWR4We0SX0UCAAFMAAYkb3V0ZXJ0ABtMc2NhbGEvY29sbGVjdGlvbi9JdGVyYXRvcjt4cHNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAwAAAAFzcgArc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLldyYXBwZWRBcnJheSRvZkludMmRLBcI15VjAgABWwAFYXJyYXl0AAJbSXhwdXIAAltJTbpgJnbqsqUCAAB4cAAAAAMAAAABAAAAAgAAAANw") + + check(immutable.TreeSet[Int]())( "rO0ABXNyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5UcmVlU2V0sRdVIDjbWAsCAAJMAAhvcmRlcmluZ3QAFUxzY2FsYS9tYXRoL09yZGVyaW5nO0wABHRyZWV0AC5Mc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvUmVkQmxhY2tUcmVlJFRyZWU7eHBzcgAYc2NhbGEubWF0aC5PcmRlcmluZyRJbnQkC4BMdr1Z51wCAAB4cHA=") + + // TODO SI-8576 unstable under -Xcheckinit + // check(immutable.TreeSet(1, 2, 3))( "rO0ABXNyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5UcmVlU2V0sRdVIDjbWAsCAAJMAAhvcmRlcmluZ3QAFUxzY2FsYS9tYXRoL09yZGVyaW5nO0wABHRyZWV0AC5Mc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvUmVkQmxhY2tUcmVlJFRyZWU7eHBzcgAYc2NhbGEubWF0aC5PcmRlcmluZyRJbnQkC4BMdr1Z51wCAAB4cHNyADFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SZWRCbGFja1RyZWUkQmxhY2tUcmVlzRxnCKenVAECAAB4cgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmVkQmxhY2tUcmVlJFRyZWVrqCSyHJbsMgIABUkABWNvdW50TAADa2V5dAASTGphdmEvbGFuZy9PYmplY3Q7TAAEbGVmdHEAfgACTAAFcmlnaHRxAH4AAkwABXZhbHVlcQB+AAh4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAnNxAH4ABgAAAAFzcQB+AAoAAAABcHBzcgAXc2NhbGEucnVudGltZS5Cb3hlZFVuaXR0pn1HHezLmgIAAHhwc3EAfgAGAAAAAXNxAH4ACgAAAANwcHEAfgAQcQB+ABA=") + + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(mutable.ArrayBuffer(1, 2, 3))( "rO0ABXNyACRzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlCdWZmZXIVOLBTg4KOcwIAA0kAC2luaXRpYWxTaXplSQAFc2l6ZTBbAAVhcnJheXQAE1tMamF2YS9sYW5nL09iamVjdDt4cAAAABAAAAADdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAEHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAFAAAAAnNxAH4ABQAAAANwcHBwcHBwcHBwcHBw") + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(mutable.ArraySeq(1, 2, 3))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwAAAAA3VyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABQAAAAJzcQB+AAUAAAAD") + check(mutable.ArrayStack(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTdGFja3bdxXbcnLBeAgACSQAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJEFycmF5U3RhY2skJGluZGV4WwAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJEFycmF5U3RhY2skJHRhYmxldAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwAAAAA3VyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAA3NxAH4ABQAAAAJzcQB+AAUAAAAB") + check(mutable.DoubleLinkedList(1, 2, 3))( "rO0ABXNyAClzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuRG91YmxlTGlua2VkTGlzdI73LKsKRr1RAgADTAAEZWxlbXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABG5leHR0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL1NlcTtMAARwcmV2cQB+AAJ4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAAc3EAfgAEAAAAAnNxAH4AAHNxAH4ABAAAAANzcQB+AABwcQB+AAtxAH4ACXEAfgAHcQB+AANw") + + check(mutable.HashMap())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAAAAAAABAB4") + check(mutable.HashMap(1 -> 1))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXEAfgAEeA==") + check(mutable.HashSet(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaFNldAAAAAAAAAABAwAAeHB3DQAAAcIAAAADAAAABQBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(new mutable.History())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGlzdG9yeUhuXxDIFJrsAgACSQAKbWF4SGlzdG9yeUwAA2xvZ3QAIExzY2FsYS9jb2xsZWN0aW9uL211dGFibGUvUXVldWU7eHAAAAPoc3IAHnNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5RdWV1ZbjMURVfOuHHAgAAeHIAJHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5NdXRhYmxlTGlzdFJpnjJ+gFbAAgADSQADbGVuTAAGZmlyc3QwdAAlTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9MaW5rZWRMaXN0O0wABWxhc3QwcQB+AAV4cAAAAABzcgAjc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkxpbmtlZExpc3Sak+nGCZHaUQIAAkwABGVsZW10ABJMamF2YS9sYW5nL09iamVjdDtMAARuZXh0dAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9TZXE7eHBwcQB+AApxAH4ACg==") + check(mutable.LinkedHashMap(1 -> 2))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJ4") + check(mutable.LinkedHashSet(1, 2, 3))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkSGFzaFNldAAAAAAAAAABAwAAeHB3DQAAAu4AAAADAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") + check(mutable.LinkedList(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkTGlzdJqT6cYJkdpRAgACTAAEZWxlbXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABG5leHR0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL1NlcTt4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAAc3EAfgAEAAAAAnNxAH4AAHNxAH4ABAAAAANzcQB+AABwcQB+AAs=") + + // TODO SI-8576 unstable under -Xcheckinit + // check(mutable.ListBuffer(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlzdEJ1ZmZlci9y9I7QyWzGAwAEWgAIZXhwb3J0ZWRJAANsZW5MAAVsYXN0MHQAKUxzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS8kY29sb24kY29sb247TAAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJExpc3RCdWZmZXIkJHN0YXJ0dAAhTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL0xpc3Q7eHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJzcQB+AAQAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHcFAAAAAAN4") + check(new mutable.StringBuilder(new java.lang.StringBuilder("123")))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuU3RyaW5nQnVpbGRlcomvqgGv1tTxAgABTAAKdW5kZXJseWluZ3QAGUxqYXZhL2xhbmcvU3RyaW5nQnVpbGRlcjt4cHNyABdqYXZhLmxhbmcuU3RyaW5nQnVpbGRlcjzV+xRaTGrLAwAAeHB3BAAAAAN1cgACW0OwJmaw4l2ErAIAAHhwAAAAEwAxADIAMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeA==") + check(mutable.UnrolledBuffer[Int]())( "rO0ABXNyACdzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuVW5yb2xsZWRCdWZmZXIAAAAAAAAAAQMAAUwAA3RhZ3QAGExzY2FsYS9yZWZsZWN0L0NsYXNzVGFnO3hwc3IAJXNjYWxhLnJlZmxlY3QuTWFuaWZlc3RGYWN0b3J5JCRhbm9uJDnN+aJJU2O1UgIAAHhyABxzY2FsYS5yZWZsZWN0LkFueVZhbE1hbmlmZXN0AAAAAAAAAAECAAFMAAh0b1N0cmluZ3QAEkxqYXZhL2xhbmcvU3RyaW5nO3hwdAADSW50dwQAAAAAeA==") + + import collection.parallel + check(parallel.immutable.ParHashMap(1 -> 2))( "rO0ABXNyAC5zY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJIYXNoTWFwAAAAAAAAAAECAANMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAEdHJpZXQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9IYXNoTWFwO3hwcHBzcgA1c2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuSGFzaE1hcCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAgMAAHhwdwQAAAABc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAcAAAACeA==") + check(parallel.immutable.ParHashSet(1, 2, 3))( "rO0ABXNyAC5zY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJIYXNoU2V0AAAAAAAAAAECAANMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAEdHJpZXQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9IYXNoU2V0O3hwcHBzcgA1c2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuSGFzaFNldCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAgMAAHhwdwQAAAADc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAcAAAACc3EAfgAHAAAAA3g=") + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(new parallel.immutable.ParRange(new Range(0, 1, 2)))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJSYW5nZQAAAAAAAAABAgAETAAXUGFyUmFuZ2VJdGVyYXRvciRtb2R1bGV0AEBMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9pbW11dGFibGUvUGFyUmFuZ2UkUGFyUmFuZ2VJdGVyYXRvciQ7TAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO0wABXJhbmdldAAiTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL1JhbmdlO3hwcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLlJhbmdlabujVKsVMg0CAAdJAANlbmRaAAdpc0VtcHR5SQALbGFzdEVsZW1lbnRJABBudW1SYW5nZUVsZW1lbnRzSQAFc3RhcnRJAARzdGVwSQAPdGVybWluYWxFbGVtZW50eHAAAAABAAAAAAAAAAABAAAAAAAAAAIAAAAC") + // TODO SI-8576 unstable under -Xcheckinit + // check(parallel.mutable.ParArray(1, 2, 3))( "rO0ABXNyACpzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFyQXJyYXkAAAAAAAAAAQMABEwAF1BhckFycmF5SXRlcmF0b3IkbW9kdWxldAA+THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvbXV0YWJsZS9QYXJBcnJheSRQYXJBcnJheUl0ZXJhdG9yJDtMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAIYXJyYXlzZXF0ACNMc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL0FycmF5U2VxO3hwcHBwc3IAMXNjYWxhLmNvbGxlY3Rpb24ucGFyYWxsZWwubXV0YWJsZS5FeHBvc2VkQXJyYXlTZXGx2OTefAodSQIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5cQB+AAd4cAAAAAN1cgATW0xqYXZhLmxhbmcuT2JqZWN0O5DOWJ8QcylsAgAAeHAAAAADcHBwAAAAA3VxAH4ACgAAABBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ADQAAAAJzcQB+AA0AAAADcHBwcHBwcHBwcHBwcHg=") + check(parallel.mutable.ParHashMap(1 -> 2))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFySGFzaE1hcAAAAAAAAAABAwACTAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO3hwcHB3DQAAAu4AAAABAAAABAFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJ4") + check(parallel.mutable.ParHashSet(1, 2, 3))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFySGFzaFNldAAAAAAAAAABAwACTAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO3hwcHB3DQAAAcIAAAADAAAAGwFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJzcQB+AAQAAAADeA==") + + check("...".r)("rO0ABXNyABlzY2FsYS51dGlsLm1hdGNoaW5nLlJlZ2V44u3Vap7wIb8CAAJMAAdwYXR0ZXJudAAZTGphdmEvdXRpbC9yZWdleC9QYXR0ZXJuO0wAJXNjYWxhJHV0aWwkbWF0Y2hpbmckUmVnZXgkJGdyb3VwTmFtZXN0ABZMc2NhbGEvY29sbGVjdGlvbi9TZXE7eHBzcgAXamF2YS51dGlsLnJlZ2V4LlBhdHRlcm5GZ9VrbkkCDQIAAkkABWZsYWdzTAAHcGF0dGVybnQAEkxqYXZhL2xhbmcvU3RyaW5nO3hwAAAAAHQAAy4uLnNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdFNlcmlhbGl6ZUVuZCSKXGNb91MLbQIAAHhweA==", + r => (r.toString)) +} diff --git a/test/files/run/t8549b.scala b/test/files/run/t8549b.scala new file mode 100644 index 0000000000..1e1bf2c0bc --- /dev/null +++ b/test/files/run/t8549b.scala @@ -0,0 +1,16 @@ + +@SerialVersionUID(42) +class C + +@SerialVersionUID(43 - 1) +class D + + +object Test extends App { + def checkId(cls: Class[_]) { + val id = cls.getDeclaredField("serialVersionUID").get(null) + assert(id == 42, (cls, id)) + } + checkId(classOf[C]) + checkId(classOf[D]) +} diff --git a/test/files/run/t8570.flags b/test/files/run/t8570.flags new file mode 100644 index 0000000000..3d1ee4760a --- /dev/null +++ b/test/files/run/t8570.flags @@ -0,0 +1 @@ +-Xcheckinit diff --git a/test/files/run/t8570.scala b/test/files/run/t8570.scala new file mode 100644 index 0000000000..bbe83e9080 --- /dev/null +++ b/test/files/run/t8570.scala @@ -0,0 +1,10 @@ +trait Trait40_1 { + val value37_2 = () + def run = { value37_2 } +} + +object Test { + def main(args: Array[String]) { + (new Trait40_1 {}).run + } +} diff --git a/test/files/run/t8570a.check b/test/files/run/t8570a.check new file mode 100644 index 0000000000..6a452c185a --- /dev/null +++ b/test/files/run/t8570a.check @@ -0,0 +1 @@ +() diff --git a/test/files/run/t8570a.flags b/test/files/run/t8570a.flags new file mode 100644 index 0000000000..3d1ee4760a --- /dev/null +++ b/test/files/run/t8570a.flags @@ -0,0 +1 @@ +-Xcheckinit diff --git a/test/files/run/t8570a.scala b/test/files/run/t8570a.scala new file mode 100644 index 0000000000..ef116e2a8a --- /dev/null +++ b/test/files/run/t8570a.scala @@ -0,0 +1,14 @@ +trait Trait40_1 { + val value37_2 = () + def run = { value37_2 } +} + +trait T1 extends Trait40_1 { + override val value37_2 = () +} + +object Test { + def main(args: Array[String]) { + println((new T1 {}).run) + } +} diff --git a/test/files/run/t8574.scala b/test/files/run/t8574.scala new file mode 100644 index 0000000000..8c23ada482 --- /dev/null +++ b/test/files/run/t8574.scala @@ -0,0 +1,27 @@ +import annotation._ + +@SerialVersionUID(42) @strictfp class Foo[@specialized(Int) T] extends Serializable { + def foo(t: T) = t +} + +object Test extends App { + def checkUID(cls: Class[_], expected: Long) = { + val actual = java.io.ObjectStreamClass.lookup(cls).getSerialVersionUID + assert(actual == expected, s"$actual != expected for ${cls}") + } + def checkStrictFp(cls: Class[_]) = { + import java.lang.reflect._ + for (m <- cls.getDeclaredMethods) { + val isStrict = Modifier.isStrict(m.getModifiers) + assert(isStrict, cls) + } + } + def check(x: AnyRef) { + checkUID(x.getClass, 42) + checkStrictFp(x.getClass) + } + + check(new Foo[String]) + check(new Foo[Int]) +} + diff --git a/test/files/run/t8601-closure-elim.flags b/test/files/run/t8601-closure-elim.flags new file mode 100644 index 0000000000..2b5fd8a7b2 --- /dev/null +++ b/test/files/run/t8601-closure-elim.flags @@ -0,0 +1 @@ +-optimize -Ydelambdafy:inline diff --git a/test/files/run/t8601-closure-elim.scala b/test/files/run/t8601-closure-elim.scala new file mode 100644 index 0000000000..2c5b03af77 --- /dev/null +++ b/test/files/run/t8601-closure-elim.scala @@ -0,0 +1,26 @@ +import scala.tools.partest.BytecodeTest +import scala.tools.asm +import scala.tools.asm.util._ +import scala.collection.JavaConverters._ + +object Test extends BytecodeTest { + val nullChecks = Set(asm.Opcodes.NEW) + + def show: Unit = { + def test(methodName: String) { + val classNode = loadClassNode("Foo") + val methodNode = getMethod(classNode, "b") + val ops = methodNode.instructions.iterator.asScala.map(_.getOpcode).toList + assert(!ops.contains(asm.Opcodes.NEW), ops)// should be allocation free if the closure is eliminiated + } + test("b") + } +} + +class Foo { + @inline final def a(x: Int => Int) = x(1) + final def b { + val delta = 0 + a(x => delta + 1) + } +} diff --git a/test/files/run/t8601.flags b/test/files/run/t8601.flags new file mode 100644 index 0000000000..1182725e86 --- /dev/null +++ b/test/files/run/t8601.flags @@ -0,0 +1 @@ +-optimize
\ No newline at end of file diff --git a/test/files/run/t8601.scala b/test/files/run/t8601.scala new file mode 100644 index 0000000000..e1afc23cc4 --- /dev/null +++ b/test/files/run/t8601.scala @@ -0,0 +1,15 @@ +object Test { + def idiv(x: Int): Unit = x / 0 + def ldiv(x: Long): Unit = x / 0 + def irem(x: Int): Unit = x % 0 + def lrem(x: Long): Unit = x % 0 + + def check(x: => Any) = try { x; sys.error("failed to throw divide by zero!") } catch { case _: ArithmeticException => } + + def main(args: Array[String]) { + check(idiv(1)) + check(ldiv(1L)) + check(irem(1)) + check(lrem(1L)) + } +} diff --git a/test/files/run/t8601b.flags b/test/files/run/t8601b.flags new file mode 100644 index 0000000000..1182725e86 --- /dev/null +++ b/test/files/run/t8601b.flags @@ -0,0 +1 @@ +-optimize
\ No newline at end of file diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala new file mode 100644 index 0000000000..9c37ce33d6 --- /dev/null +++ b/test/files/run/t8601b.scala @@ -0,0 +1,14 @@ +object Test { + def len(x: Array[String]): Unit = x.length + def load(x: Array[String]): Unit = x(0) + def newarray(i: Int): Unit = new Array[Int](i) + + def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + def checkNegSize(x: => Any) = try { x; sys.error("failed to throw NegativeArraySizeException!") } catch { case _: NegativeArraySizeException => } + + def main(args: Array[String]) { + check(len(null)) // bug: did not NPE + check(load(null)) + checkNegSize(newarray(-1)) + } +} diff --git a/test/files/run/t8601c.flags b/test/files/run/t8601c.flags new file mode 100644 index 0000000000..1182725e86 --- /dev/null +++ b/test/files/run/t8601c.flags @@ -0,0 +1 @@ +-optimize
\ No newline at end of file diff --git a/test/files/run/t8601c.scala b/test/files/run/t8601c.scala new file mode 100644 index 0000000000..c487d6825e --- /dev/null +++ b/test/files/run/t8601c.scala @@ -0,0 +1,12 @@ +object Test { + def loadField(x: scala.runtime.IntRef): Unit = x.elem + def storeField(x: scala.runtime.IntRef): Unit = x.elem = 42 + + def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(loadField(null)) // bug: did not NPE under -Ydead-code + check(storeField(null)) + + } +} diff --git a/test/files/run/t8601d.flags b/test/files/run/t8601d.flags new file mode 100644 index 0000000000..1182725e86 --- /dev/null +++ b/test/files/run/t8601d.flags @@ -0,0 +1 @@ +-optimize
\ No newline at end of file diff --git a/test/files/run/t8601d.scala b/test/files/run/t8601d.scala new file mode 100644 index 0000000000..ac89963d67 --- /dev/null +++ b/test/files/run/t8601d.scala @@ -0,0 +1,8 @@ +object Test { + def monitor(x: AnyRef): Unit = {x.synchronized(()); ()} + def check(x: => Any) = try { x; sys.error("failed to throw NPE") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(monitor(null)) + } +} diff --git a/test/files/run/t8601e.flags b/test/files/run/t8601e.flags new file mode 100644 index 0000000000..49d036a887 --- /dev/null +++ b/test/files/run/t8601e.flags @@ -0,0 +1 @@ +-optimize diff --git a/test/files/run/t8601e/StaticInit.class b/test/files/run/t8601e/StaticInit.class Binary files differnew file mode 100644 index 0000000000..99a0e2a643 --- /dev/null +++ b/test/files/run/t8601e/StaticInit.class diff --git a/test/files/run/t8601e/StaticInit.java b/test/files/run/t8601e/StaticInit.java new file mode 100644 index 0000000000..7543ed98b8 --- /dev/null +++ b/test/files/run/t8601e/StaticInit.java @@ -0,0 +1,8 @@ +public class StaticInit { + static { + if ("".isEmpty()) { + throw new RuntimeException(); + } + } + public static int fld = 42; +} diff --git a/test/files/run/t8601e/Test.scala b/test/files/run/t8601e/Test.scala new file mode 100644 index 0000000000..838114f6a7 --- /dev/null +++ b/test/files/run/t8601e/Test.scala @@ -0,0 +1,12 @@ +class C { + def foo: Unit = {StaticInit.fld} +} + +object Test extends App { + try { + new C().foo + sys.error("StaticInit.<clinit> was not run!") + } catch { + case t: ExceptionInInitializerError => + } +} diff --git a/test/files/run/t8607.scala b/test/files/run/t8607.scala new file mode 100644 index 0000000000..1b8ef9bbd0 --- /dev/null +++ b/test/files/run/t8607.scala @@ -0,0 +1,36 @@ +package p1 { + private[p1] trait B extends Any { + def a: Any = "" + } + + class C(val value: Int) extends AnyVal with B { + // def b = "" + } +} + +object Test { + def main(args: Array[String]) { + val c = new p1.C(42) + c.a + /* + new p1.C.<init>( + c.$asInstanceOf[scala.this.Int]() + ).a(); + + + new p1.C.<init>( + new p1.C.<init>( + c.$asInstanceOf[scala.this.Int]() + ).$asInstanceOf[ErasedValueType(class C, scala.this.Int)]() + .$asInstanceOf[scala.this.Int]() + ).a(); + + new p1.C.<init>( + new p1.C.<init>(c) + .$asInstanceOf[scala.this.Int]() + .$asInstanceOf[scala.this.Int]() + ).a(); + + */ + } +} diff --git a/test/files/run/t8608-no-format.scala b/test/files/run/t8608-no-format.scala new file mode 100644 index 0000000000..71c369a7ea --- /dev/null +++ b/test/files/run/t8608-no-format.scala @@ -0,0 +1,15 @@ + +import scala.tools.partest.JavapTest + +object Test extends JavapTest { + def code = """ + |f"hello, world" + |:javap -prv - + """.stripMargin + + // no format + override def yah(res: Seq[String]) = { + // note: avoid the word "information" + res forall (!_.contains("StringOps.format")) + } +} diff --git a/test/files/run/t8610.check b/test/files/run/t8610.check new file mode 100644 index 0000000000..b3ab7a9cef --- /dev/null +++ b/test/files/run/t8610.check @@ -0,0 +1,7 @@ +t8610.scala:6: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. + signature: X.f(p: (Int, Int)): Int + given arguments: 3, 4 + after adaptation: X.f((3, 4): (Int, Int)) + def g = f(3, 4) // adapted + ^ +Hi, $name diff --git a/test/files/run/t8610.flags b/test/files/run/t8610.flags new file mode 100644 index 0000000000..4195dec383 --- /dev/null +++ b/test/files/run/t8610.flags @@ -0,0 +1 @@ +-Xlint:adapted-args diff --git a/test/files/run/t8610.scala b/test/files/run/t8610.scala new file mode 100644 index 0000000000..dd9e8e861e --- /dev/null +++ b/test/files/run/t8610.scala @@ -0,0 +1,13 @@ + +// flags don't warn on u +case class X(name: String) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist +} + +object Test extends App { + // poignant demonstration + Console println X("Bob").x +} diff --git a/test/files/run/t8611a.flags b/test/files/run/t8611a.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/run/t8611a.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/run/t8611a.scala b/test/files/run/t8611a.scala new file mode 100644 index 0000000000..99304df762 --- /dev/null +++ b/test/files/run/t8611a.scala @@ -0,0 +1,16 @@ +trait K +trait L + +object O { + type LK = K with L + val A: LK = new K with L + val B: LK = new K with L +} + +object Test extends App { + val scrut: O.LK = O.B + scrut match { + case O.A => ??? + case O.B => // spurious unreachable + } +} diff --git a/test/files/run/t8611b.flags b/test/files/run/t8611b.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/run/t8611b.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/run/t8611b.scala b/test/files/run/t8611b.scala new file mode 100644 index 0000000000..2df17c9ca0 --- /dev/null +++ b/test/files/run/t8611b.scala @@ -0,0 +1,54 @@ +sealed trait KrafsDescription + +abstract class NotWorkingEnum extends Enumeration { + + type ExtendedValue = Value with KrafsDescription + + def Enum(inDescription: String): ExtendedValue = { + new Val(nextId) with KrafsDescription { + } + } +} + +abstract class WorkingEnum extends Enumeration { + + type ExtendedValue = Value + + def Enum(inDescription: String): ExtendedValue = { + new Val(nextId) { + } + } +} + +object NotWorkingTab extends NotWorkingEnum { + val a = Enum("A") + val b = Enum("B") +} + +object WorkingTab extends WorkingEnum { + val a = Enum("A") + val b = Enum("B") +} + +object Test extends App { + testGris() + testWorking() + + def testGris() { + val pipp = NotWorkingTab.b + pipp match { + case NotWorkingTab.a => ??? + case NotWorkingTab.b => + case _ => ??? + } + } + + def testWorking() { + val stuff = WorkingTab.a + stuff match { + case WorkingTab.a => + case WorkingTab.b => ??? + case _ => ??? + } + } +} diff --git a/test/files/run/t8611c.flags b/test/files/run/t8611c.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/run/t8611c.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/run/t8611c.scala b/test/files/run/t8611c.scala new file mode 100644 index 0000000000..2bd17f29a5 --- /dev/null +++ b/test/files/run/t8611c.scala @@ -0,0 +1,21 @@ +trait K +trait L + +object O { + type LK = K with L +} + +object Test extends App { + local + + def local = { + val A: O.LK = new K with L + val B: O.LK = new K with L + val scrut: O.LK = A + scrut match { + case B if "".isEmpty => ??? + case A => + case B => ??? + } + } +} diff --git a/test/files/run/t8637.check b/test/files/run/t8637.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/run/t8637.check diff --git a/test/files/run/t8637.scala b/test/files/run/t8637.scala new file mode 100644 index 0000000000..99c8d4c413 --- /dev/null +++ b/test/files/run/t8637.scala @@ -0,0 +1,9 @@ +import scala.reflect.runtime.universe._ +import scala.reflect.runtime.currentMirror +import scala.tools.reflect.ToolBox + +object Test extends App { + val tb = currentMirror.mkToolBox() + tb.compile(q"true > true") + tb.typecheck(q"true > true") +}
\ No newline at end of file diff --git a/test/files/run/t8680.scala b/test/files/run/t8680.scala new file mode 100644 index 0000000000..2bce09c507 --- /dev/null +++ b/test/files/run/t8680.scala @@ -0,0 +1,53 @@ +object Test extends App { + def pre(n: Int) = (-n to -1).toStream + + def cyc(m: Int) = { + lazy val s: Stream[Int] = (0 until m).toStream #::: s + s + } + + def precyc(n: Int, m: Int) = pre(n) #::: cyc(m) + + def str(s: Stream[Int]) = { + val b = new StringBuilder + s.addString(b, "", "", "") + b.toString + } + + def goal(n: Int, m: Int) = (-n until m).mkString + "..." + + // Check un-forced cyclic and non-cyclic streams + assert(str(pre(2)) == pre(2).take(1).toList.mkString + "?") + assert(str(cyc(2)) == cyc(2).take(1).toList.mkString + "?") + assert(str(precyc(2,2)) == precyc(2,2).take(1).toList.mkString + "?") + assert(!pre(2).hasDefiniteSize) + assert(!cyc(2).hasDefiniteSize) + assert(!precyc(2,2).hasDefiniteSize) + + // Check forced cyclic and non-cyclic streams + assert(str(pre(2).force) == (-2 to -1).mkString) + assert(str(cyc(2).force) == (0 until 2).mkString + "...") + assert(str(precyc(2,2).force) == (-2 until 2).mkString + "...") + assert(pre(2).force.hasDefiniteSize) + assert(!cyc(2).force.hasDefiniteSize) + assert(!precyc(2,2).force.hasDefiniteSize) + + // Special cases + assert(str(cyc(1).force) == goal(0,1)) + assert(str(precyc(1,6).force) == goal(1,6)) + assert(str(precyc(6,1).force) == goal(6,1)) + + // Make sure there are no odd/even problems + for (n <- 3 to 4; m <- 3 to 4) { + assert(precyc(n,m).mkString == goal(n,m), s"mkString $n $m") + assert(!precyc(n,m).force.hasDefiniteSize, s"hasDef $n$m") + } + + // Make sure there are no cycle/prefix modulus problems + for (i <- 6 to 8) { + assert(precyc(i,3).mkString == goal(i,3), s"mkString $i 3") + assert(precyc(3,i).mkString == goal(3,i), s"mkString 3 $i") + assert(!precyc(i,3).force.hasDefiniteSize, s"hasDef $i 3") + assert(!precyc(3,i).force.hasDefiniteSize, s"hasDef 3 $i") + } +} diff --git a/test/files/run/t8690.check b/test/files/run/t8690.check new file mode 100644 index 0000000000..72f076c4d8 --- /dev/null +++ b/test/files/run/t8690.check @@ -0,0 +1,2 @@ +non-empty iterator +abcdef diff --git a/test/files/run/t8690.scala b/test/files/run/t8690.scala new file mode 100644 index 0000000000..ab8b45b2a7 --- /dev/null +++ b/test/files/run/t8690.scala @@ -0,0 +1,12 @@ +import scala.io.Source +import java.io.ByteArrayInputStream + +object Test extends App { + val txt = "abcdef" + + val in = new ByteArrayInputStream(txt.getBytes()); + val source = Source.fromInputStream(in); + println(source.toString) // forces the BufferedSource to look at the head of the input + + println(source.mkString) // used to return "bcdef" ... +} diff --git a/test/files/run/t8708_b.check b/test/files/run/t8708_b.check new file mode 100644 index 0000000000..30be62a307 --- /dev/null +++ b/test/files/run/t8708_b.check @@ -0,0 +1,8 @@ +Scope{ + def <init>: <?>; + sealed abstract trait T extends ; + def foo: <?> +} +Scope{ + def f: <?> +} diff --git a/test/files/run/t8708_b/A_1.scala b/test/files/run/t8708_b/A_1.scala new file mode 100644 index 0000000000..e767420f9e --- /dev/null +++ b/test/files/run/t8708_b/A_1.scala @@ -0,0 +1,8 @@ +package p + +class C { + + sealed trait T { def f: Int } + + def foo: T = new T { def f = 1 } +} diff --git a/test/files/run/t8708_b/Test_2.scala b/test/files/run/t8708_b/Test_2.scala new file mode 100644 index 0000000000..c978490609 --- /dev/null +++ b/test/files/run/t8708_b/Test_2.scala @@ -0,0 +1,21 @@ +import scala.tools.partest._ +import java.io.{Console => _, _} + +object Test extends DirectTest { + + override def extraSettings: String = "-usejavacp -cp " + testOutput.path + + override def code = "" + + override def show(): Unit = { + val g = newCompiler() + withRun(g)(r => { + val c = g.rootMirror.getRequiredClass("p.C") + println(c.info.decls) + val t = c.info.member(g.newTypeName("T")) + // this test ensrues that the <local child> dummy class symbol is not entered in the + // scope of trait T during unpickling. + println(t.info.decls) + }) + } +} diff --git a/test/files/run/t8738.scala b/test/files/run/t8738.scala new file mode 100644 index 0000000000..6898301db7 --- /dev/null +++ b/test/files/run/t8738.scala @@ -0,0 +1,16 @@ +object Test { + def check(a: Range, b: Range) = (a == b) == (a.toList == b.toList) + def main(args: Array[String]) { + val lo = -2 to 2 + val hi = lo + val step = List(-6,-2,-1,1,2,6) + for (i <- lo; j <- hi; n <- step; k <- lo; l <- hi; m <- step) { + assert( + check(i until j by n, k until l by m) && + check(i until j by n, k to l by m) && + check(i to j by n, k until l by m) && + check(i to j by n, k to l by m) + ) + } + } +} diff --git a/test/files/run/t8764.check b/test/files/run/t8764.check new file mode 100644 index 0000000000..6260069602 --- /dev/null +++ b/test/files/run/t8764.check @@ -0,0 +1,5 @@ +IntOnly: should return an unboxed int +Int: int +IntAndDouble: should just box and return Anyval +Double: class java.lang.Double +Int: class java.lang.Integer diff --git a/test/files/run/t8764.flags b/test/files/run/t8764.flags new file mode 100644 index 0000000000..48fd867160 --- /dev/null +++ b/test/files/run/t8764.flags @@ -0,0 +1 @@ +-Xexperimental diff --git a/test/files/run/t8764.scala b/test/files/run/t8764.scala new file mode 100644 index 0000000000..decc658f6e --- /dev/null +++ b/test/files/run/t8764.scala @@ -0,0 +1,16 @@ +object Test extends App { +case class IntOnly(i: Int, j: Int) + +println("IntOnly: should return an unboxed int") +val a = IntOnly(1, 2) +val i: Int = a.productElement(0) +println(s"Int: ${a.productElement(0).getClass}") + +case class IntAndDouble(i: Int, d: Double) + +println("IntAndDouble: should just box and return Anyval") +val b = IntAndDouble(1, 2.0) +val j: AnyVal = b.productElement(0) +println(s"Double: ${b.productElement(1).getClass}") +println(s"Int: ${b.productElement(0).getClass}") +} diff --git a/test/files/run/t8803.check b/test/files/run/t8803.check new file mode 100644 index 0000000000..bd26a0fb14 --- /dev/null +++ b/test/files/run/t8803.check @@ -0,0 +1,16 @@ +a +b +b +c +a +b +b +c +a +b +b +c +a +b +b +c diff --git a/test/files/run/t8803.scala b/test/files/run/t8803.scala new file mode 100644 index 0000000000..2e56180502 --- /dev/null +++ b/test/files/run/t8803.scala @@ -0,0 +1,57 @@ +class A { + def m = "a" + protected def n = "a" +} + +trait B { + def m = "b" + protected def n = "b" +} + +class C extends A with B { + override def m = "c" + override protected def n = "c" + + val f1 = () => super[A].m + val f2 = () => super[B].m + val f3 = () => super.m + val f4 = () => this.m + + val g1 = new runtime.AbstractFunction0[String] { def apply() = C.super[A].m } + val g2 = new runtime.AbstractFunction0[String] { def apply() = C.super[B].m } + val g3 = new runtime.AbstractFunction0[String] { def apply() = C.super.m } + val g4 = new runtime.AbstractFunction0[String] { def apply() = C.this.m } + + val h1 = () => super[A].n + val h2 = () => super[B].n + val h3 = () => super.n + val h4 = () => this.n + + val i1 = new runtime.AbstractFunction0[String] { def apply() = C.super[A].n } + val i2 = new runtime.AbstractFunction0[String] { def apply() = C.super[B].n } + val i3 = new runtime.AbstractFunction0[String] { def apply() = C.super.n } + val i4 = new runtime.AbstractFunction0[String] { def apply() = C.this.n } +} + +object Test extends App { + val c = new C + println(c.f1()) + println(c.f2()) + println(c.f3()) + println(c.f4()) + + println(c.g1()) + println(c.g2()) + println(c.g3()) + println(c.g4()) + + println(c.h1()) + println(c.h2()) + println(c.h3()) + println(c.h4()) + + println(c.i1()) + println(c.i2()) + println(c.i3()) + println(c.i4()) +} diff --git a/test/files/run/t8823.scala b/test/files/run/t8823.scala new file mode 100644 index 0000000000..0ac653566a --- /dev/null +++ b/test/files/run/t8823.scala @@ -0,0 +1,10 @@ +class Tuple2Int(val encoding: Long) extends AnyVal with Product2[Int, Int] { + def canEqual(that: Any) = false + def _1: Int = 1 + def _2: Int = 2 +} + +object Test extends App { + assert(new Tuple2Int(0)._1 == 1) + assert(new Tuple2Int(0)._2 == 2) +} diff --git a/test/files/run/t8843-repl-xlat.scala b/test/files/run/t8843-repl-xlat.scala new file mode 100644 index 0000000000..6426dbe7d4 --- /dev/null +++ b/test/files/run/t8843-repl-xlat.scala @@ -0,0 +1,33 @@ + +import scala.tools.partest.SessionTest + +// Handy hamburger helper for repl resources +object Test extends SessionTest { + def session = +"""Type in expressions to have them evaluated. +Type :help for more information. + +scala> $intp.isettings.unwrapStrings = false +$intp.isettings.unwrapStrings: Boolean = false + +scala> class Bippy +defined class Bippy + +scala> $intp.classLoader getResource "Bippy.class" +res0: java.net.URL = memory:(memory)/$line4/$read$$iw$$iw$Bippy.class + +scala> ($intp.classLoader getResources "Bippy.class").nextElement +res1: java.net.URL = memory:(memory)/$line4/$read$$iw$$iw$Bippy.class + +scala> ($intp.classLoader classBytes "Bippy").nonEmpty +res2: Boolean = true + +scala> ($intp.classLoader classAsStream "Bippy") != null +res3: Boolean = true + +scala> $intp.classLoader getResource "Bippy" +res4: java.net.URL = null + +scala> :quit""" +} + diff --git a/test/files/run/t8845.flags b/test/files/run/t8845.flags new file mode 100644 index 0000000000..c30091d3de --- /dev/null +++ b/test/files/run/t8845.flags @@ -0,0 +1 @@ +-Ybackend:GenBCode diff --git a/test/files/run/t8845.scala b/test/files/run/t8845.scala new file mode 100644 index 0000000000..8ccdbdadc7 --- /dev/null +++ b/test/files/run/t8845.scala @@ -0,0 +1,17 @@ +// crashes compiler under GenASM, works under GenBCode. +object Interpreter { + def mkDataProp(i: Int) = i + def break(n: Int): Unit = + try { + n match { + case _ => + val newDesc = mkDataProp(n) + n match { case _ => return } + } + } catch { case e: Throwable => } + finally { } +} + +object Test extends App { + Interpreter.break(0) +} diff --git a/test/files/run/t8852a.scala b/test/files/run/t8852a.scala new file mode 100644 index 0000000000..cbff8ab75b --- /dev/null +++ b/test/files/run/t8852a.scala @@ -0,0 +1,34 @@ +import scala.tools.partest._ + +// Test that static methods in Java interfaces (new in Java 8) +// are callable from jointly compiler Scala code. +object Test extends CompilerTest { + import global._ + + override lazy val units: List[CompilationUnit] = { + // This test itself does not depend on JDK8. + javaCompilationUnits(global)(staticMethodInInterface) ++ + compilationUnits(global)(scalaClient) + } + + private def staticMethodInInterface = """ +public interface Interface { + public static int staticMethod() { + return 42; + } +} + + """ + + private def scalaClient = """ +object Test { + val x: Int = Interface.staticMethod() +} + +class C extends Interface // expect no errors about unimplemented members. + + """ + + // We're only checking we can compile it. + def check(source: String, unit: global.CompilationUnit): Unit = () +} diff --git a/test/files/run/t8888.flags b/test/files/run/t8888.flags new file mode 100644 index 0000000000..48b438ddf8 --- /dev/null +++ b/test/files/run/t8888.flags @@ -0,0 +1 @@ +-Ydelambdafy:method diff --git a/test/files/run/t8888.scala b/test/files/run/t8888.scala new file mode 100644 index 0000000000..36cc1ddf3e --- /dev/null +++ b/test/files/run/t8888.scala @@ -0,0 +1,12 @@ +class C { + final def resume: Unit = (this: Any) match { + case x : C => (x: Any) match { + case y : C => + () => (x, y) // used to trigger a ClassFormatError under -Ydelambdafy:method + } + } +} + +object Test extends App { + new C().resume +} diff --git a/test/files/run/t8893.scala b/test/files/run/t8893.scala new file mode 100644 index 0000000000..6fef8ae912 --- /dev/null +++ b/test/files/run/t8893.scala @@ -0,0 +1,40 @@ +import annotation.tailrec + +object Test { + def a(): Option[String] = Some("a") + + def test1: Any = { + a() match { + case Some(b1) => + a() match { + case Some(b2) => + @tailrec + def tick(i: Int): Unit = if (i < 0) () else tick(i - 1) + tick(10000000) // testing that this doesn't SOE + case None => None + } + case None => None + } + } + + def test2: Any = { + a() match { + case Some(b1) => + a() match { + case Some(b2) => + @tailrec + def tick(i: Int): Unit = if (i < 0) () else tick(i - 1) + tick(10000000) // testing that this doesn't SOE + case None => test1 + } + case None => + test1 // not a tail call + test1 + } + } + + def main(args: Array[String]) { + test1 + test2 + } +} diff --git a/test/files/run/t8893b.scala b/test/files/run/t8893b.scala new file mode 100644 index 0000000000..19120871aa --- /dev/null +++ b/test/files/run/t8893b.scala @@ -0,0 +1,15 @@ +// Testing that recursive calls in tail positions are replaced with +// jumps, even though the method contains recursive calls outside +// of the tail position. +object Test { + def tick(i : Int): Unit = + if (i == 0) () + else if (i == 42) { + tick(0) /*not in tail posiiton*/ + tick(i - 1) + } else tick(i - 1) + + def main(args: Array[String]): Unit = { + tick(1000000) + } +} diff --git a/test/files/run/t8907.scala b/test/files/run/t8907.scala new file mode 100644 index 0000000000..7952ac82d9 --- /dev/null +++ b/test/files/run/t8907.scala @@ -0,0 +1,39 @@ +import scala.tools.partest._ +import java.io.File + +object Test extends StoreReporterDirectTest { + def code = ??? + + def compileCode(code: String) = { + val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") + compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code) + } + + def show(): Unit = { + compileCode(""" + class C { class Inner } + + class D { + object O { + def foo(c: C)(i: c.Inner): c.Inner = ??? + } + } + """) + assert(filteredInfos.isEmpty, filteredInfos) + deleteClass("C") + compileCode(""" + class E { + def foo = { + (null: D).toString + } + } + """) + assert(storeReporter.infos.isEmpty, storeReporter.infos.mkString("\n")) // Included a MissingRequirementError before. + } + + def deleteClass(name: String) { + val classFile = new File(testOutput.path, name + ".class") + assert(classFile.exists) + assert(classFile.delete()) + } +} diff --git a/test/files/run/t8925.check b/test/files/run/t8925.check new file mode 100644 index 0000000000..112e7005df --- /dev/null +++ b/test/files/run/t8925.check @@ -0,0 +1,2 @@ +bar +abcd diff --git a/test/files/run/t8925.flags b/test/files/run/t8925.flags new file mode 100644 index 0000000000..ffc65f4b81 --- /dev/null +++ b/test/files/run/t8925.flags @@ -0,0 +1 @@ +-Yopt:l:none -Ybackend:GenBCode diff --git a/test/files/run/t8925.scala b/test/files/run/t8925.scala new file mode 100644 index 0000000000..33f4505f03 --- /dev/null +++ b/test/files/run/t8925.scala @@ -0,0 +1,31 @@ +object Ex { + def unapply(t: Throwable): Option[Throwable] = Some(t) +} + +class A { + var x = "" + + def bar = + try { + "bar" + } finally { + try { + x += "a" + } finally { + x += "b" + try { + x += "c" + throw null + } catch { + case Ex(_) => + x += "d" + } + } + } +} + +object Test extends App { + val a = new A + println(a.bar) + println(a.x) +} diff --git a/test/files/run/t8931.check b/test/files/run/t8931.check new file mode 100644 index 0000000000..d08546b5a9 --- /dev/null +++ b/test/files/run/t8931.check @@ -0,0 +1 @@ +List(interface B) diff --git a/test/files/run/t8931.scala b/test/files/run/t8931.scala new file mode 100644 index 0000000000..11718471bc --- /dev/null +++ b/test/files/run/t8931.scala @@ -0,0 +1,15 @@ + +trait A + +trait B extends A + +class C extends A with B + +object Test extends App { + val c = classOf[C] + + println(c.getGenericInterfaces.toList) + + assert(c.getGenericInterfaces.length == c.getInterfaces.length, + s"mismatch between ${c.getGenericInterfaces} and ${c.getInterfaces}") +} diff --git a/test/files/run/t8933.check b/test/files/run/t8933.check new file mode 100644 index 0000000000..d5ef468b98 --- /dev/null +++ b/test/files/run/t8933.check @@ -0,0 +1 @@ +'traitSymbol diff --git a/test/files/run/t8933/A_1.scala b/test/files/run/t8933/A_1.scala new file mode 100644 index 0000000000..996e3b4a2c --- /dev/null +++ b/test/files/run/t8933/A_1.scala @@ -0,0 +1,6 @@ +class MotherClass + +trait MixinWithSymbol { + self: MotherClass => + def symbolFromTrait: Symbol = 'traitSymbol +} diff --git a/test/files/run/t8933/Test_2.scala b/test/files/run/t8933/Test_2.scala new file mode 100644 index 0000000000..c506a7c51f --- /dev/null +++ b/test/files/run/t8933/Test_2.scala @@ -0,0 +1,10 @@ +class MotherClass extends MixinWithSymbol { + val classSymbol = 'classSymbol +} + +object Test { + def main(args: Array[String]) { + val symbol = (new MotherClass).symbolFromTrait + println(symbol) + } +} diff --git a/test/files/run/t8933b/A.scala b/test/files/run/t8933b/A.scala new file mode 100644 index 0000000000..d25d893c6f --- /dev/null +++ b/test/files/run/t8933b/A.scala @@ -0,0 +1,4 @@ +trait MixinWithSymbol { + self: MotherClass => + def symbolFromTrait: Any = 'traitSymbol +} diff --git a/test/files/run/t8933b/Test.scala b/test/files/run/t8933b/Test.scala new file mode 100644 index 0000000000..46eedd660f --- /dev/null +++ b/test/files/run/t8933b/Test.scala @@ -0,0 +1,9 @@ +class MotherClass extends MixinWithSymbol { + def foo = 'sym1 +} + +object Test { + def main(args: Array[String]) { + (new MotherClass).symbolFromTrait + } +} diff --git a/test/files/run/t8933c.scala b/test/files/run/t8933c.scala new file mode 100644 index 0000000000..22011bc323 --- /dev/null +++ b/test/files/run/t8933c.scala @@ -0,0 +1,14 @@ +object Test { + def main(args: Array[String]): Unit = { + try { + {throw T; Symbol}.apply("a") + assert(false, "exception not thrown") + } catch { + case T => // ok + case t: Throwable => + assert(false, "wrong not thrown: " + t) + } + } +} + +object T extends Throwable diff --git a/test/files/run/t8960.scala b/test/files/run/t8960.scala new file mode 100644 index 0000000000..a58ac53d33 --- /dev/null +++ b/test/files/run/t8960.scala @@ -0,0 +1,72 @@ +object Test extends App { + def test(o: AnyRef, sp: Boolean = false) = { + val isSpecialized = o.getClass.getSuperclass.getName contains "$sp" + val isDelambdafyMethod = o.getClass.getName contains "$lambda$" + assert( + // delambdafy:method doesn't currently emit specialized anonymous function classes + if (sp) (isSpecialized || isDelambdafyMethod) else !isSpecialized, + o.getClass.getName) + + val Some(f) = o.getClass.getDeclaredFields.find(_.getName == "serialVersionUID") + assert(f.getLong(null) == 0l) + } + + test(() => (), sp = true) + test(() => 1, sp = true) + test(() => "") + + test((x: Int) => x, sp = true) + test((x: Boolean) => x) + test((x: Int) => "") + + test((x1: Int, x2: Int) => 0d, sp = true) + test((x1: Int, x2: AnyRef) => 0d) + test((x1: Any, x2: Any) => x1) + + // scala> println((for (i <- 3 to 22) yield (for (j <- 1 to i) yield s"x$j: Int").mkString(" test((", ", ", ") => x1)")).mkString("\n")) + + test((x1: Int, x2: Int, x3: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int) => x1) + test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int, x22: Int) => x1) + + test({ + case x: Int => x + }: PartialFunction[Int, Int], sp = true) + + test({ + case x: Int => x + }: PartialFunction[Any, Any]) + + test({ + case x: Int => () + }: PartialFunction[Int, Unit], sp = true) + + test({ + case x: String => 1 + }: PartialFunction[String, Int]) + + test({ + case x: String => () + }: PartialFunction[String, Unit]) + + test({ + case x: String => x + }: PartialFunction[String, String]) +} diff --git a/test/files/run/t9003.flags b/test/files/run/t9003.flags new file mode 100644 index 0000000000..49d036a887 --- /dev/null +++ b/test/files/run/t9003.flags @@ -0,0 +1 @@ +-optimize diff --git a/test/files/run/t9003.scala b/test/files/run/t9003.scala new file mode 100644 index 0000000000..4f24712201 --- /dev/null +++ b/test/files/run/t9003.scala @@ -0,0 +1,71 @@ +object Single { + var i = 0 + def isEmpty = false + def get = i + def unapply(a: Single.type) = this +} + +object Product { + var i = 0 + def _1: Int = i + def _2: String = ??? + def productArity = 2 + def unapply(a: Product.type) = this + def isEmpty = false + def get: this.type = this +} + +object Sequence { + var i = 0 + def apply(n: Int): Int = i + def length = 2 + def unapplySeq(a: Sequence.type) = this + def isEmpty = false + def get = this +} + +object Test { + def main(args: Array[String]): Unit = { + def assertZero(i: Int) = assert(i == 0) + + Single match { + case Single(i) => + Single.i = 1 + assertZero(i) // fails under -optimize + } + + Product match { + case Product(i, _) => + Product.i = 1 + assertZero(i) // fails under -optimize + } + + Sequence match { + case Sequence(i, _ @ _*) => + Sequence.i = 1 + assertZero(i) // okay + } + + Sequence.i = 0 + Sequence match { + case Sequence(_, i) => + Sequence.i = 1 + assertZero(i) // okay + } + + val buffer = collection.mutable.Buffer(0, 0) + buffer match { + case Seq(_, i) => + buffer(1) = 1 + assertZero(i) // failed + } + + case class CaseSequence(as: Int*) + val buffer1 = collection.mutable.Buffer(0, 0) + CaseSequence(buffer1: _*) match { + case CaseSequence(_, i) => + buffer1(1) = 1 + assertZero(i) // failed + } + } +} diff --git a/test/files/run/t9027.check b/test/files/run/t9027.check new file mode 100644 index 0000000000..3429254286 --- /dev/null +++ b/test/files/run/t9027.check @@ -0,0 +1,19 @@ +{ + { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, true)); + $buf.$amp$plus(new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true)); + $buf + }; + println("hello, world.") +} +{ + { + val $buf = new _root_.scala.xml.NodeBuffer(); + $buf.$amp$plus(new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, true)); + $buf.$amp$plus(new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true)); + $buf.$amp$plus(new _root_.scala.xml.Elem(null, "c", _root_.scala.xml.Null, $scope, true)); + $buf + }; + println("hello, world.") +} diff --git a/test/files/run/t9027.scala b/test/files/run/t9027.scala new file mode 100644 index 0000000000..26238147da --- /dev/null +++ b/test/files/run/t9027.scala @@ -0,0 +1,15 @@ + +// used to be parsed as .println +object Test extends App { + import reflect.runtime._, universe._ + + val trees = List( + q"""<a/><b/> + println("hello, world.")""", + q"""<a/> + <b/> + <c/> + println("hello, world.")""" + ) + trees foreach println +} diff --git a/test/files/run/t9030.scala b/test/files/run/t9030.scala new file mode 100644 index 0000000000..48d24e5b54 --- /dev/null +++ b/test/files/run/t9030.scala @@ -0,0 +1,19 @@ +object Test extends App { + + // For these methods, the compiler emits calls to BoxesRuntime.equalsNumNum/equalsNumChar/equalsNumObject directly + + def numNum(a: java.lang.Number, b: java.lang.Number) = assert(a == b) + def numChar(a: java.lang.Number, b: java.lang.Character) = assert(a == b) + def numObject(a: java.lang.Number, b: java.lang.Object) = assert(a == b) + + // The compiler doesn't use equalsCharObject directly, but still adding an example for completeness + + def charObject(a: java.lang.Character, b: java.lang.Object) = assert(a == b) + + numNum(new Integer(1), new Integer(1)) + numChar(new Integer(97), new Character('a')) + numObject(new Integer(1), new Integer(1)) + numObject(new Integer(97), new Character('a')) + + charObject(new Character('a'), new Integer(97)) +} diff --git a/test/files/run/t9097.scala b/test/files/run/t9097.scala new file mode 100644 index 0000000000..aa2b23bbac --- /dev/null +++ b/test/files/run/t9097.scala @@ -0,0 +1,34 @@ +import scala.tools.partest._ +import java.io.{Console => _, _} + +object Test extends StoreReporterDirectTest { + + override def extraSettings: String = List( + "-usejavacp", + "-Xfatal-warnings", + "-Ybackend:GenBCode", + "-Ydelambdafy:method", + "-Xprint:delambdafy", + s"-d ${testOutput.path}" + ) mkString " " + + override def code = """package o + |package a { + | class C { + | def hihi = List(1,2).map(_ => "") + | } + |} + |package object a { + | def f = 1 + |} + |""".stripMargin.trim + + override def show(): Unit = { + val baos = new java.io.ByteArrayOutputStream() + Console.withOut(baos)(Console.withErr(baos)(compile())) + assert(!storeReporter.hasErrors, message = filteredInfos map (_.msg) mkString "; ") + val out = baos.toString("UTF-8") + // was 2 before the fix, the two PackageDefs for a would both contain the ClassDef for the closure + assert(out.lines.count(_ contains "class hihi$1") == 1, out) + } +} diff --git a/test/files/run/t9102.scala b/test/files/run/t9102.scala new file mode 100644 index 0000000000..c46cf0e4b4 --- /dev/null +++ b/test/files/run/t9102.scala @@ -0,0 +1,81 @@ + +object Test extends App { + import reflect.runtime._, universe._ + + class C { def f(i: Int, j: => Int) = i + j } + + class V(val v: Int) extends AnyVal { def doubled = 2 * v } + class D { def f(i: Int, j: V) = i + j.doubled } + + class E(i: Int, j: V) + + locally { + val ms = typeOf[C].member(TermName("f")).asMethod + val im = currentMirror reflect (new C) + val mm = im reflectMethod ms + assert(mm(2,3) == 5) + } + locally { + val ms = typeOf[D].member(TermName("f")).asMethod + val im = currentMirror reflect (new D) + val mm = im reflectMethod ms + assert(mm(2, new V(3)) == 8) + } + locally { + val ms = typeOf[E].typeSymbol.asClass.primaryConstructor + val cm = currentMirror reflectClass typeOf[E].typeSymbol.asClass + val mm = cm reflectConstructor ms.asMethod + assert(mm(42, new V(7)).isInstanceOf[E]) + } +} + +/* Session tests without special init code should reside in simple script files. + * Also, provide filters such as for `(bound to C@74f7d1d2)`. + +import scala.tools.partest.SessionTest + +object Test extends SessionTest { +//Welcome to Scala version 2.11.6 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_40). + def session = + s"""|Type in expressions to have them evaluated. + |Type :help for more information. + | + |scala> import reflect.runtime._, universe._ + |import reflect.runtime._ + |import universe._ + | + |scala> class C { def f(i: Int, j: => Int) = i + j } + |defined class C + | + |scala> typeOf[C].member(TermName("f")) + |res0: reflect.runtime.universe.Symbol = method f + | + |scala> .asMethod + |res1: reflect.runtime.universe.MethodSymbol = method f + | + |scala> currentMirror reflect (new C) + |res2: reflect.runtime.universe.InstanceMirror = instance mirror for C@74f7d1d2 + | + |scala> res2 reflectMethod res1 + |res3: reflect.runtime.universe.MethodMirror = method mirror for def f(i: scala.Int,j: => scala.Int): scala.Int (bound to C@74f7d1d2) + | + |scala> res3(2,3) + |res4: Any = 5 + | + |scala> :quit""" +} +*/ + +/* was: +scala> res3(2,3) +java.lang.IllegalArgumentException + at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) + at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) + at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) + at java.lang.reflect.Method.invoke(Method.java:497) + at scala.reflect.runtime.JavaMirrors$JavaMirror$JavaMethodMirror.jinvokeraw(JavaMirrors.scala:335) + at scala.reflect.runtime.JavaMirrors$JavaMirror$JavaMethodMirror.jinvoke(JavaMirrors.scala:339) + at scala.reflect.runtime.JavaMirrors$JavaMirror$JavaTransformingMethodMirror.apply(JavaMirrors.scala:436) + ... 33 elided +*/ + diff --git a/test/files/run/t9170.scala b/test/files/run/t9170.scala new file mode 100644 index 0000000000..25a0e84581 --- /dev/null +++ b/test/files/run/t9170.scala @@ -0,0 +1,58 @@ + +import scala.tools.partest.SessionTest + +object Test extends SessionTest { + + override def stripMargins = false + + def session = +"""Type in expressions to have them evaluated. +Type :help for more information. + +scala> object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 } +<console>:7: error: double definition: +def f[A](a: => A): Int at line 7 and +def f[A](a: => Either[Exception,A]): Int at line 7 +have same type after erasure: (a: Function0)Int + object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 } + ^ + +scala> object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 } +<console>:7: error: double definition: +def f[A](a: => A): Int at line 7 and +def f[A](a: => Either[Exception,A]): Int at line 7 +have same type after erasure: (a: Function0)Int + object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 } + ^ + +scala> object Y { + | def f[A](a: => A) = 1 + | def f[A](a: => Either[Exception, A]) = 2 + | } +<console>:9: error: double definition: +def f[A](a: => A): Int at line 8 and +def f[A](a: => Either[Exception,A]): Int at line 9 +have same type after erasure: (a: Function0)Int + def f[A](a: => Either[Exception, A]) = 2 + ^ + +scala> :pa +// Entering paste mode (ctrl-D to finish) + +object Y { + def f[A](a: => A) = 1 + def f[A](a: => Either[Exception, A]) = 2 +} + +// Exiting paste mode, now interpreting. + +<console>:9: error: double definition: +def f[A](a: => A): Int at line 8 and +def f[A](a: => Either[Exception,A]): Int at line 9 +have same type after erasure: (a: Function0)Int + def f[A](a: => Either[Exception, A]) = 2 + ^ + +scala> :quit""" +} + diff --git a/test/files/run/t9182.check b/test/files/run/t9182.check new file mode 100644 index 0000000000..80e8b6c558 --- /dev/null +++ b/test/files/run/t9182.check @@ -0,0 +1,3 @@ +constructor package +method A +object A diff --git a/test/files/run/t9182.scala b/test/files/run/t9182.scala new file mode 100644 index 0000000000..1768aa688e --- /dev/null +++ b/test/files/run/t9182.scala @@ -0,0 +1,12 @@ +// Main.scala +package object ops { + object A + def A(a: Any) = () +} + +object Test { + def main(args: Array[String]): Unit = { + val pack = scala.reflect.runtime.currentMirror.staticModule("ops.package") + println(pack.info.decls.toList.map(_.toString).sorted.mkString("\n")) + } +} diff --git a/test/files/run/t9219.check b/test/files/run/t9219.check new file mode 100644 index 0000000000..3509ece003 --- /dev/null +++ b/test/files/run/t9219.check @@ -0,0 +1,3 @@ +Stream(1, 2, ?) +Stream(1, 2, 3, 4, ?) +Stream(1, 2, 3, 4, 5, 6, ?) diff --git a/test/files/run/t9219.scala b/test/files/run/t9219.scala new file mode 100644 index 0000000000..c15f55faac --- /dev/null +++ b/test/files/run/t9219.scala @@ -0,0 +1,11 @@ +object Test extends App { + def check[U](f: Stream[Int] => U) = { + val s = Stream.from(1) + f(s) + println(s) + } + + check(_.tail) + check(_.take(4).force) + check(_(5)) +} diff --git a/test/files/run/t9223.scala b/test/files/run/t9223.scala new file mode 100644 index 0000000000..78767b158d --- /dev/null +++ b/test/files/run/t9223.scala @@ -0,0 +1,8 @@ +class X(val x: String) +class Y(y: => String) extends X(y) { def f = y } + +object Test { + def main(args: Array[String]): Unit = { + assert(new Y("hi").f == "hi") + } +} diff --git a/test/files/run/t9223b.scala b/test/files/run/t9223b.scala new file mode 100644 index 0000000000..2afc7ddfe0 --- /dev/null +++ b/test/files/run/t9223b.scala @@ -0,0 +1,8 @@ +class X(x: => String) { def xx = x } +class Y(y: String) extends X(y) { def f = y } + +object Test { + def main(args: Array[String]): Unit = { + assert(new Y("hi").f == "hi") + } +} diff --git a/test/files/run/t9252.check b/test/files/run/t9252.check new file mode 100644 index 0000000000..b00d748f7f --- /dev/null +++ b/test/files/run/t9252.check @@ -0,0 +1 @@ +class [Lscala.runtime.BoxedUnit; diff --git a/test/files/run/t9252.scala b/test/files/run/t9252.scala new file mode 100644 index 0000000000..da698948e1 --- /dev/null +++ b/test/files/run/t9252.scala @@ -0,0 +1,5 @@ +import scala.reflect.runtime.universe._ + +object Test extends App { + println(rootMirror.runtimeClass(typeOf[Array[Unit]])) +}
\ No newline at end of file diff --git a/test/files/run/t9268.check b/test/files/run/t9268.check new file mode 100644 index 0000000000..90ef940eb3 --- /dev/null +++ b/test/files/run/t9268.check @@ -0,0 +1,5 @@ +Compiling Client1 +pos: NoPosition Class Waiter not found - continuing with a stub. WARNING +Compiling Client2 +pos: NoPosition Class Waiter not found - continuing with a stub. WARNING +pos: NoPosition Unable to locate class corresponding to inner class entry for Predicate in owner Waiter ERROR diff --git a/test/files/run/t9268/Java.java b/test/files/run/t9268/Java.java new file mode 100644 index 0000000000..c9a0bec3ff --- /dev/null +++ b/test/files/run/t9268/Java.java @@ -0,0 +1,12 @@ +public class Java { +} + +class Partial { + public <E extends java.lang.Exception> long waitFor(long l, Waiter.Predicate<E> pred) throws E { + return 0L; + } +} + +class Waiter { + interface Predicate<E> {} +} diff --git a/test/files/run/t9268/Test.scala b/test/files/run/t9268/Test.scala new file mode 100644 index 0000000000..813cbe7b60 --- /dev/null +++ b/test/files/run/t9268/Test.scala @@ -0,0 +1,40 @@ +import scala.tools.partest._ +import java.io.File + +object Test extends StoreReporterDirectTest { + def code = ??? + + def compileCode(code: String) = { + val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") + compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code) + } + + def client1 = """ + class Client1 { def p(p: Partial) = p.toString } + """ + + def client2 = """ + class Client2 { def p(p: Partial) = p.waitFor() } + """ + + def deleteClass(s: String) = { + val f = new File(testOutput.path, s + ".class") + assert(f.exists) + f.delete() + } + + def show(): Unit = { + deleteClass("Waiter") + deleteClass("Waiter$Predicate") + + // Used to crash in Java Generic Signature parsing + println("Compiling Client1") + compileCode(client1) + println(storeReporter.infos.mkString("\n")) + storeReporter.reset() + println("Compiling Client2") + compileCode(client2) + println(storeReporter.infos.mkString("\n")) + } +} + diff --git a/test/files/run/tailcalls.check b/test/files/run/tailcalls.check index 7607921856..92d4f8a3c8 100644 --- a/test/files/run/tailcalls.check +++ b/test/files/run/tailcalls.check @@ -50,6 +50,10 @@ test NonTailCall.f2 test TailCall.b1 was successful test TailCall.b2 was successful test FancyTailCalls.tcTryLocal was successful +test FancyTailCalls.tcInBooleanExprFirstOp was successful +test FancyTailCalls.tcInBooleanExprSecondOp was successful +test FancyTailCalls.tcInIfCond was successful +test FancyTailCalls.tcInPatternGuard was successful test FancyTailCalls.differentInstance was successful test PolyObject.tramp was successful #partest avian @@ -104,5 +108,9 @@ test NonTailCall.f2 test TailCall.b1 was successful test TailCall.b2 was successful test FancyTailCalls.tcTryLocal was successful +test FancyTailCalls.tcInBooleanExprFirstOp was successful +test FancyTailCalls.tcInBooleanExprSecondOp was successful +test FancyTailCalls.tcInIfCond was successful +test FancyTailCalls.tcInPatternGuard was successful test FancyTailCalls.differentInstance was successful test PolyObject.tramp was successful diff --git a/test/files/run/tailcalls.scala b/test/files/run/tailcalls.scala index 1653b14de9..8df2dcfcb6 100644 --- a/test/files/run/tailcalls.scala +++ b/test/files/run/tailcalls.scala @@ -213,6 +213,33 @@ class FancyTailCalls { } finally {} } + def tcInBooleanExprFirstOp(x: Int, v: Int): Boolean = { + { + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) + } == v && true + } + def tcInBooleanExprSecondOp(x: Int, v: Int): Boolean = { + true && { + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) + } == v + } + def tcInIfCond(x: Int, v: Int): Boolean = { + if ({ + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) + } == v) true else false + } + def tcInPatternGuard(x: Int, v: Int): Boolean = + v match { + case _ if + { + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) == v + } => true + } + import FancyTailCalls._ final def differentInstance(n: Int, v: Int): Int = { if (n == 0) v @@ -376,8 +403,12 @@ object Test { check_success_b("TailCall.b2", TailCall.b2(max), true) val FancyTailCalls = new FancyTailCalls; - check_success("FancyTailCalls.tcTryLocal", FancyTailCalls.tcTryLocal(max, max), max) - check_success("FancyTailCalls.differentInstance", FancyTailCalls.differentInstance(max, 42), 42) + check_success("FancyTailCalls.tcTryLocal", FancyTailCalls.tcTryLocal(max, max), max) + check_success_b("FancyTailCalls.tcInBooleanExprFirstOp", FancyTailCalls.tcInBooleanExprFirstOp(max, max), true) + check_success_b("FancyTailCalls.tcInBooleanExprSecondOp", FancyTailCalls.tcInBooleanExprSecondOp(max, max), true) + check_success_b("FancyTailCalls.tcInIfCond", FancyTailCalls.tcInIfCond(max, max), true) + check_success_b("FancyTailCalls.tcInPatternGuard", FancyTailCalls.tcInPatternGuard(max, max), true) + check_success("FancyTailCalls.differentInstance", FancyTailCalls.differentInstance(max, 42), 42) check_success("PolyObject.tramp", PolyObject.tramp[Int](max), 0) } diff --git a/test/files/run/tpeCache-tyconCache.check b/test/files/run/tpeCache-tyconCache.check index a892f5477a..ff604819e0 100644 --- a/test/files/run/tpeCache-tyconCache.check +++ b/test/files/run/tpeCache-tyconCache.check @@ -16,4 +16,4 @@ res0: Boolean = true scala> AnyRefClass.tpe eq AnyRefClass.typeConstructor res1: Boolean = true -scala> +scala> :quit diff --git a/test/files/run/typetags_serialize.check b/test/files/run/typetags_serialize.check index f79436ea5d..22928a2e94 100644 --- a/test/files/run/typetags_serialize.check +++ b/test/files/run/typetags_serialize.check @@ -1,2 +1,3 @@ -java.io.NotSerializableException: scala.reflect.api.TypeTags$PredefTypeCreator -java.io.NotSerializableException: Test$$typecreator1$1 +TypeTag[Int] +TypeTag[String] +TypeTag[Test.C[Double]] diff --git a/test/files/run/typetags_serialize.scala b/test/files/run/typetags_serialize.scala index 3c842e6cc9..a7a7845232 100644 --- a/test/files/run/typetags_serialize.scala +++ b/test/files/run/typetags_serialize.scala @@ -4,6 +4,10 @@ import scala.reflect.runtime.{universe => ru} import scala.reflect.runtime.{currentMirror => cm} object Test extends App { + class C[A] { + def m(a: A): Int = 5 + } + def test(tag: TypeTag[_]) = try { val fout = new ByteArrayOutputStream() @@ -26,4 +30,5 @@ object Test extends App { test(implicitly[TypeTag[Int]]) test(implicitly[TypeTag[String]]) + test(implicitly[TypeTag[C[Double]]]) }
\ No newline at end of file diff --git a/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala b/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala index 1fbdc62a1e..3d2b9f77be 100644 --- a/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala +++ b/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala @@ -36,8 +36,8 @@ object Test extends StoreReporterDirectTest { println(filteredInfos.mkString("\n")) storeReporter.infos.clear() compileApp(); - // we should get bad symbolic reference errors, because we're trying to use an implicit that can't be unpickled + // we should get "missing or invalid dependency detected" errors, because we're trying to use an implicit that can't be unpickled // but we don't know the number of these errors and their order, so I just ignore them all - println(filteredInfos.filterNot(_.msg.contains("bad symbolic reference")).mkString("\n")) + println(filteredInfos.filterNot(_.msg.contains("missing or invalid dependency detected")).mkString("\n")) } } diff --git a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala index 6804baa0c3..a865f4d137 100644 --- a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala +++ b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala @@ -40,8 +40,8 @@ object Test extends StoreReporterDirectTest { println(filteredInfos.mkString("\n")) storeReporter.infos.clear() compileApp(); - // we should get bad symbolic reference errors, because we're trying to use an implicit that can't be unpickled + // we should get "missing or invalid dependency detected" errors, because we're trying to use an implicit that can't be unpickled // but we don't know the number of these errors and their order, so I just ignore them all - println(filteredInfos.filterNot (_.msg.contains("bad symbolic reference")).mkString("\n")) + println(filteredInfos.filterNot (_.msg.contains("missing or invalid dependency detected")).mkString("\n")) } } diff --git a/test/files/run/unittest_collection.check b/test/files/run/unittest_collection.check index 844ca54682..df1629dd7e 100644 --- a/test/files/run/unittest_collection.check +++ b/test/files/run/unittest_collection.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details diff --git a/test/files/run/valueClassSelfType.scala b/test/files/run/valueClassSelfType.scala new file mode 100644 index 0000000000..47a3764b0a --- /dev/null +++ b/test/files/run/valueClassSelfType.scala @@ -0,0 +1,52 @@ +trait T + +class V1(val l: Long) extends AnyVal { self: T => + def foo: V1 = self + def bar: T = self +} + +class V2(val l: Long) extends AnyVal { self => + def foo: V2 = self +} + +class V3(val l: Long) extends AnyVal { self: Long => + def foo: V3 = self + def bar: Long = self +} + +// non-value classes + +class C1(val l: Long) { self: T => + def foo: C1 = self + def bar: T = self +} + +class C2(val l: Long) { self => + def foo: C2 = self +} + +class C3(val l: Long) { self: Long => + def foo: C3 = self + def bar: Long = self +} + +object Test extends App { + // Rejected: superclass V1 is not a subclass of the superclass Object of the mixin trait T + // new V1(1l) with T + + assert(new V2(1l).foo.l == 1l) + + // Rejected: V3 does not conform to its self-type V3 with Long + // new V3(1l) + + val c2 = new C1(2l) with T + assert(c2.foo.l + c2.bar.asInstanceOf[C1].l == 4l) + + assert(new C2(3l).foo.l == 3l) + + // Rejected: C3 does not conform to its self-type C3 with Long + // new C3(4l) + + // Rejected: class Long needs to be a trait to be mixed in + // new C3(4l) with Long +} diff --git a/test/files/run/various-flat-classpath-types.check b/test/files/run/various-flat-classpath-types.check new file mode 100644 index 0000000000..401f707d0e --- /dev/null +++ b/test/files/run/various-flat-classpath-types.check @@ -0,0 +1,12 @@ +ZipBin() +JarBin() +DirBin() +ZipSrc() +JarSrc() +DirSrc() +NestedZipBin() +NestedJarBin() +NestedDirBin() +NestedZipSrc() +NestedJarSrc() +NestedDirSrc()
\ No newline at end of file diff --git a/test/files/run/various-flat-classpath-types.scala b/test/files/run/various-flat-classpath-types.scala new file mode 100644 index 0000000000..d39019e885 --- /dev/null +++ b/test/files/run/various-flat-classpath-types.scala @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2014 Contributor. All rights reserved. + */ + +import java.io.{File => JFile, FileInputStream, FileOutputStream} +import java.util.zip.{ZipEntry, ZipOutputStream} +import scala.reflect.io.{Directory, File} +import scala.tools.nsc.classpath.FlatClassPath.RootPackage +import scala.tools.nsc.classpath.PackageNameUtils +import scala.tools.nsc.io.Jar + +/** + * Generates directories, jars and zip files containing sources and classes + * (the result of a compilation which is executed here) + * and use them as a class- and sourcepath during compilation and running + * created application. At the end everything is cleaned up. + * + * It can test also current, recursive classpath. Just right now we force + * flat classpath to test it also when the recursive one would be set as a default. + */ +object Test { + + private implicit class JFileOps(file: JFile) { + + def createDir(newDirName: String) = { + val newDir = new JFile(file, newDirName) + newDir.mkdir() + newDir + } + + def createSrcFile(newFileName: String) = createFile(newFileName + ".scala") + + def createFile(fullFileName: String) = { + val newFile = new JFile(file, fullFileName) + newFile.createNewFile() + newFile + } + + def writeAll(text: String): Unit = File(file) writeAll text + + def moveContentToZip(zipName: String): Unit = { + val newZip = zipsDir createFile s"$zipName.zip" + val outputStream = new ZipOutputStream(new FileOutputStream(newZip)) + + def addFileToZip(dirPrefix: String = "")(fileToAdd: JFile): Unit = + if (fileToAdd.isDirectory) { + val dirEntryName = fileToAdd.getName + "/" + outputStream.putNextEntry(new ZipEntry(dirEntryName)) + fileToAdd.listFiles() foreach addFileToZip(dirEntryName) + } else { + val inputStream = new FileInputStream(fileToAdd) + outputStream.putNextEntry(new ZipEntry(dirPrefix + fileToAdd.getName)) + + val buffer = new Array[Byte](1024) + var count = inputStream.read(buffer) + while (count > 0) { + outputStream.write(buffer, 0, count) + count = inputStream.read(buffer) + } + + inputStream.close() + } + + file.listFiles() foreach addFileToZip() + outputStream.close() + + cleanDir(file) + } + + def moveContentToJar(jarName: String): Unit = { + val newJar = jarsDir createFile s"$jarName.jar" + Jar.create(file = File(newJar), sourceDir = Directory(file), mainClass = "won't be used") + cleanDir(file) + } + + def path: String = file.getAbsolutePath + } + + private case class DirRep(name: String, nestedDirs: Seq[DirRep] = Nil, sourceFiles: Seq[String] = Nil) + + private val compiler = new scala.tools.nsc.MainClass + private val appRunner = new scala.tools.nsc.MainGenericRunner + private val classPathImplFlag = "-YclasspathImpl:flat" + private val javaClassPath = sys.props("java.class.path") + + // creates a test dir in a temporary dir containing compiled files of this test + // root dir will be automatically deleted after the end of test + private val rootDir = new JFile(sys.props("partest.output")) + private val testDir = rootDir createDir s"cp-tests-${System.currentTimeMillis()}" + + private val jarsDir = testDir createDir "jars" + private val zipsDir = testDir createDir "zips" + private val srcDir = testDir createDir "src" + private val binDir = testDir createDir "bin" + private val outDir = testDir createDir "out" + + def main(args: Array[String]): Unit = { + createClassesZipInZipsDir() + createClassesJarInJarsDir() + createClassesInBinDir() + createSourcesZipInZipsDir() + createSourcesJarInJarsDir() + createSourcesInSrcDir() + compileFinalApp() + runApp() + // at the end all created files will be deleted automatically + } + + private def createClassesZipInZipsDir(): Unit = { + val baseFileName = "ZipBin" + createStandardSrcHierarchy(baseFileName) + compileSrc(baseFileName) + outDir moveContentToZip "Bin" + cleanDir(srcDir) + } + + private def createClassesJarInJarsDir(): Unit = { + val baseFileName = "JarBin" + createStandardSrcHierarchy(baseFileName) + compileSrc(baseFileName) + outDir moveContentToJar "Bin" + cleanDir(srcDir) + } + + private def createClassesInBinDir(): Unit = { + val baseFileName = "DirBin" + createStandardSrcHierarchy(baseFileName) + compileSrc(baseFileName, destination = binDir) + cleanDir(srcDir) + } + + private def createSourcesZipInZipsDir(): Unit = { + createStandardSrcHierarchy(baseFileName = "ZipSrc") + srcDir moveContentToZip "Src" + } + + private def createSourcesJarInJarsDir(): Unit = { + createStandardSrcHierarchy(baseFileName = "JarSrc") + srcDir moveContentToJar "Src" + } + + private def createSourcesInSrcDir(): Unit = { + createStandardSrcHierarchy(baseFileName = "DirSrc") + + val appFile = srcDir createSrcFile "Main" + appFile writeAll s"""import nested._ + | object Main extends App { + | println(new ZipBin) + | println(new JarBin) + | println(new DirBin) + | println(new ZipSrc) + | println(new JarSrc) + | println(new DirSrc) + | + | println(new NestedZipBin) + | println(new NestedJarBin) + | println(new NestedDirBin) + | println(new NestedZipSrc) + | println(new NestedJarSrc) + | println(new NestedDirSrc) + | } + """.stripMargin + } + + private def compileFinalApp(): Unit = { + val classPath = mkPath(javaClassPath, binDir.path, zipsDir.path + "/Bin.zip", jarsDir.path + "/Bin.jar") + val sourcePath = mkPath(srcDir.path, zipsDir.path + "/Src.zip", jarsDir.path + "/Src.jar") + + compiler.process(Array(classPathImplFlag, "-cp", classPath, "-sourcepath", sourcePath, + "-d", outDir.path, s"${srcDir.path}/Main.scala")) + } + + private def runApp(): Unit = { + val classPath = mkPath(javaClassPath, outDir.path, binDir.path, zipsDir.path + "/Bin.zip", jarsDir.path + "/Bin.jar") + appRunner.process(Array(classPathImplFlag, "-cp", classPath, "Main")) + } + + private def createStandardSrcHierarchy(baseFileName: String): Unit = + createSources(RootPackage, srcDir, + DirRep("", + nestedDirs = Seq(DirRep("nested", sourceFiles = Seq("Nested" + baseFileName))), + sourceFiles = Seq(baseFileName) + ) + ) + + private def createSources(pkg: String, dirFile: JFile, dirRep: DirRep): Unit = { + dirRep.nestedDirs foreach { rep => + val nestedDir = dirFile createDir rep.name + val nestedPkg = PackageNameUtils.packagePrefix(pkg) + rep.name + createSources(nestedPkg, nestedDir, rep) + } + + val pkgHeader = if (pkg == RootPackage) "" else s"package $pkg\n\n" + dirRep.sourceFiles foreach { srcName => + val text = s"""${pkgHeader}case class $srcName(x: String = "")""" + val srcFile = dirFile createSrcFile srcName + srcFile writeAll text + } + } + + private def compileSrc(baseFileName: String, destination: JFile = outDir): Unit = { + val srcDirPath = srcDir.path + compiler.process(Array(classPathImplFlag, "-cp", javaClassPath, "-d", destination.path, + s"$srcDirPath/$baseFileName.scala", s"$srcDirPath/nested/Nested$baseFileName.scala")) + } + + private def cleanDir(dir: JFile): Unit = + dir.listFiles().foreach { file => + if (file.isDirectory) cleanDir(file) + file.delete() + } + + private def mkPath(pathEntries: String*) = pathEntries.mkString(File.pathSeparator) +} diff --git a/test/files/run/virtpatmat_nested_lists.flags b/test/files/run/virtpatmat_nested_lists.flags new file mode 100644 index 0000000000..ca9a4c0697 --- /dev/null +++ b/test/files/run/virtpatmat_nested_lists.flags @@ -0,0 +1 @@ +-Ypatmat-exhaust-depth off
\ No newline at end of file diff --git a/test/files/run/virtpatmat_opt_sharing.flags b/test/files/run/virtpatmat_opt_sharing.flags new file mode 100644 index 0000000000..ca9a4c0697 --- /dev/null +++ b/test/files/run/virtpatmat_opt_sharing.flags @@ -0,0 +1 @@ +-Ypatmat-exhaust-depth off
\ No newline at end of file diff --git a/test/files/run/virtpatmat_staging.flags b/test/files/run/virtpatmat_staging.flags index 48fd867160..0a22f7c729 100644 --- a/test/files/run/virtpatmat_staging.flags +++ b/test/files/run/virtpatmat_staging.flags @@ -1 +1,2 @@ +-Yrangepos:false -Xexperimental diff --git a/test/files/run/virtpatmat_typetag.check b/test/files/run/virtpatmat_typetag.check index cac9d9a4d6..00df8b5e81 100644 --- a/test/files/run/virtpatmat_typetag.check +++ b/test/files/run/virtpatmat_typetag.check @@ -1,9 +1,9 @@ -1 is not a Int; it's a class java.lang.Integer +1 is a Int 1 is a java.lang.Integer 1 is not a java.lang.String; it's a class java.lang.Integer true is a Any woele is a java.lang.String -1 is not a Int; it's a class java.lang.Integer +1 is a Int 1 is a java.lang.Integer 1 is not a java.lang.String; it's a class java.lang.Integer true is a Any diff --git a/test/files/run/xMigration.check b/test/files/run/xMigration.check new file mode 100644 index 0000000000..378f7bb6c3 --- /dev/null +++ b/test/files/run/xMigration.check @@ -0,0 +1,49 @@ +Type in expressions to have them evaluated. +Type :help for more information. + +scala> Map(1 -> "eis").values // no warn +res0: Iterable[String] = MapLike(eis) + +scala> :setting -Xmigration:none + +scala> Map(1 -> "eis").values // no warn +res1: Iterable[String] = MapLike(eis) + +scala> :setting -Xmigration:any + +scala> Map(1 -> "eis").values // warn +<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0: +`values` returns `Iterable[B]` rather than `Iterator[B]`. + Map(1 -> "eis").values // warn + ^ +res2: Iterable[String] = MapLike(eis) + +scala> :setting -Xmigration:2.8 + +scala> Map(1 -> "eis").values // no warn +res3: Iterable[String] = MapLike(eis) + +scala> :setting -Xmigration:2.7 + +scala> Map(1 -> "eis").values // warn +<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0: +`values` returns `Iterable[B]` rather than `Iterator[B]`. + Map(1 -> "eis").values // warn + ^ +res4: Iterable[String] = MapLike(eis) + +scala> :setting -Xmigration:2.11 + +scala> Map(1 -> "eis").values // no warn +res5: Iterable[String] = MapLike(eis) + +scala> :setting -Xmigration // same as :any + +scala> Map(1 -> "eis").values // warn +<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0: +`values` returns `Iterable[B]` rather than `Iterator[B]`. + Map(1 -> "eis").values // warn + ^ +res6: Iterable[String] = MapLike(eis) + +scala> :quit diff --git a/test/files/run/xMigration.scala b/test/files/run/xMigration.scala new file mode 100644 index 0000000000..688e878397 --- /dev/null +++ b/test/files/run/xMigration.scala @@ -0,0 +1,19 @@ +import scala.tools.partest.ReplTest + +object Test extends ReplTest { + def code = """ +Map(1 -> "eis").values // no warn +:setting -Xmigration:none +Map(1 -> "eis").values // no warn +:setting -Xmigration:any +Map(1 -> "eis").values // warn +:setting -Xmigration:2.8 +Map(1 -> "eis").values // no warn +:setting -Xmigration:2.7 +Map(1 -> "eis").values // warn +:setting -Xmigration:2.11 +Map(1 -> "eis").values // no warn +:setting -Xmigration // same as :any +Map(1 -> "eis").values // warn + """ +} diff --git a/test/files/scalacheck/Ctrie.scala b/test/files/scalacheck/Ctrie.scala index 714f1c3b09..eef9d06f37 100644 --- a/test/files/scalacheck/Ctrie.scala +++ b/test/files/scalacheck/Ctrie.scala @@ -186,6 +186,25 @@ object Test extends Properties("concurrent.TrieMap") { }) } + property("concurrent getOrElseUpdate") = forAll(threadCounts, sizes) { + (p, sz) => + val totalInserts = new java.util.concurrent.atomic.AtomicInteger + val ct = new TrieMap[Wrap, String] + + val results = inParallel(p) { + idx => + (0 until sz) foreach { + i => + val v = ct.getOrElseUpdate(Wrap(i), idx + ":" + i) + if (v == idx + ":" + i) totalInserts.incrementAndGet() + } + } + + (totalInserts.get == sz) && ((0 until sz) forall { + case i => ct(Wrap(i)).split(":")(1).toInt == i + }) + } + } diff --git a/test/files/scalacheck/nan-ordering.scala b/test/files/scalacheck/nan-ordering.scala index 2094a46e37..05e97a13c9 100644 --- a/test/files/scalacheck/nan-ordering.scala +++ b/test/files/scalacheck/nan-ordering.scala @@ -42,16 +42,16 @@ object Test extends Properties("NaN-Ordering") { property("Float equiv") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.equiv(d1, d2) == (d1 == d2) } property("Float reverse.min") = forAll(specFloats, specFloats) { (d1, d2) => { - val mathmin = math.min(d1, d2) + val mathmax = math.max(d1, d2) val numericmin = numFloat.reverse.min(d1, d2) - mathmin == numericmin || mathmin.isNaN && numericmin.isNaN + mathmax == numericmin || mathmax.isNaN && numericmin.isNaN } } property("Float reverse.max") = forAll(specFloats, specFloats) { (d1, d2) => { - val mathmax = math.max(d1, d2) + val mathmin = math.min(d1, d2) val numericmax = numFloat.reverse.max(d1, d2) - mathmax == numericmax || mathmax.isNaN && numericmax.isNaN + mathmin == numericmax || mathmin.isNaN && numericmax.isNaN } } @@ -105,16 +105,16 @@ object Test extends Properties("NaN-Ordering") { property("Double equiv") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.equiv(d1, d2) == (d1 == d2) } property("Double reverse.min") = forAll(specDoubles, specDoubles) { (d1, d2) => { - val mathmin = math.min(d1, d2) + val mathmax = math.max(d1, d2) val numericmin = numDouble.reverse.min(d1, d2) - mathmin == numericmin || mathmin.isNaN && numericmin.isNaN + mathmax == numericmin || mathmax.isNaN && numericmin.isNaN } } property("Double reverse.max") = forAll(specDoubles, specDoubles) { (d1, d2) => { - val mathmax = math.max(d1, d2) + val mathmin = math.min(d1, d2) val numericmax = numDouble.reverse.max(d1, d2) - mathmax == numericmax || mathmax.isNaN && numericmax.isNaN + mathmin == numericmax || mathmin.isNaN && numericmax.isNaN } } diff --git a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala index 774d6f428b..468bcb6dd1 100644 --- a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala +++ b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala @@ -36,7 +36,7 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col // used to check if constructed collection is valid def checkDataStructureInvariants(orig: Traversable[T], cf: AnyRef) = { - // can be overriden in subclasses + // can be overridden in subclasses true } diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala index 45392de582..409f07037e 100644 --- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala @@ -310,4 +310,16 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") { val cases = List(cq"a => b", cq"c => d") assertEqAst(q"{ case ..$cases }", "{ case a => b case c => d }") } + + property("SI-8609 a") = test { + val q1 = q"val x = 1" + val q2 = q"..$q1; val y = 2" + assert(q2 ≈ q"{ val x = 1; val y = 2 }") + } + + property("SI-8609 b") = test { + val q1 = q"import foo.bar" + val q2 = q"..$q1; val y = 2" + assert(q2 ≈ q"{ import foo.bar; val y = 2 }") + } } diff --git a/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala index 49ffaff630..07e8f3faac 100644 --- a/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala @@ -246,4 +246,11 @@ object TermDeconstructionProps extends QuasiquoteProperties("term deconstruction assert(f ≈ `new`) assert(argss.isEmpty) } + + property("SI-8703 extract block with single expression") = test { + val q"{ $a }" = Block(Nil, q"1") + val Literal(Constant(1)) = a + val q"{ $b }" = q"2" + val Literal(Constant(2)) = b + } } diff --git a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala index a5d526191f..f84df269ca 100644 --- a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala +++ b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala @@ -1,9 +1,8 @@ import org.scalacheck._, Prop._, Gen._, Arbitrary._ import scala.reflect.runtime.universe._, Flag._, internal.reificationSupport._ -object TypecheckedProps extends QuasiquoteProperties("typechecked") { - - +object TypecheckedProps extends QuasiquoteProperties("typechecked") + with TypecheckedTypes { property("tuple term") = test { val q"(..$elements)" = typecheck(q"(1, 2)") assert(elements ≈ List(q"1", q"2")) @@ -166,7 +165,7 @@ trait TypecheckedTypes { self: QuasiquoteProperties => } property("applied type") = test { - val tt = typecheckTyp(q"Map[Int, Int]") + val tt = typecheckTyp(tq"Map[Int, Int]") val tq"$tpt[..$tpts]" = tt val tq"scala.this.Predef.Map" = tpt val List(tq"scala.Int", tq"scala.Int") = tpts @@ -205,7 +204,7 @@ trait TypecheckedTypes { self: QuasiquoteProperties => property("annotated type") = test { val tq"$tpt @$annot" = typecheckTyp(tq"Int @unchecked") val tq"scala.Int" = tpt - val q"new unchecked" = annot + val tq"unchecked" = annot } property("existential type") = test { diff --git a/test/files/scalap/t8679.check b/test/files/scalap/t8679.check new file mode 100644 index 0000000000..938b76783f --- /dev/null +++ b/test/files/scalap/t8679.check @@ -0,0 +1,3503 @@ +class T8679 extends scala.AnyRef { + def this() = { /* compiled code */ } + def foo1(): scala.Int = { /* compiled code */ } + def foo2(): scala.Int = { /* compiled code */ } + def foo3(): scala.Int = { /* compiled code */ } + def foo4(): scala.Int = { /* compiled code */ } + def foo5(): scala.Int = { /* compiled code */ } + def foo6(): scala.Int = { /* compiled code */ } + def foo7(): scala.Int = { /* compiled code */ } + def foo8(): scala.Int = { /* compiled code */ } + def foo9(): scala.Int = { /* compiled code */ } + def foo10(): scala.Int = { /* compiled code */ } + def foo11(): scala.Int = { /* compiled code */ } + def foo12(): scala.Int = { /* compiled code */ } + def foo13(): scala.Int = { /* compiled code */ } + def foo14(): scala.Int = { /* compiled code */ } + def foo15(): scala.Int = { /* compiled code */ } + def foo16(): scala.Int = { /* compiled code */ } + def foo17(): scala.Int = { /* compiled code */ } + def foo18(): scala.Int = { /* compiled code */ } + def foo19(): scala.Int = { /* compiled code */ } + def foo20(): scala.Int = { /* compiled code */ } + def foo21(): scala.Int = { /* compiled code */ } + def foo22(): scala.Int = { /* compiled code */ } + def foo23(): scala.Int = { /* compiled code */ } + def foo24(): scala.Int = { /* compiled code */ } + def foo25(): scala.Int = { /* compiled code */ } + def foo26(): scala.Int = { /* compiled code */ } + def foo27(): scala.Int = { /* compiled code */ } + def foo28(): scala.Int = { /* compiled code */ } + def foo29(): scala.Int = { /* compiled code */ } + def foo30(): scala.Int = { /* compiled code */ } + def foo31(): scala.Int = { /* compiled code */ } + def foo32(): scala.Int = { /* compiled code */ } + def foo33(): scala.Int = { /* compiled code */ } + def foo34(): scala.Int = { /* compiled code */ } + def foo35(): scala.Int = { /* compiled code */ } + def foo36(): scala.Int = { /* compiled code */ } + def foo37(): scala.Int = { /* compiled code */ } + def foo38(): scala.Int = { /* compiled code */ } + def foo39(): scala.Int = { /* compiled code */ } + def foo40(): scala.Int = { /* compiled code */ } + def foo41(): scala.Int = { /* compiled code */ } + def foo42(): scala.Int = { /* compiled code */ } + def foo43(): scala.Int = { /* compiled code */ } + def foo44(): scala.Int = { /* compiled code */ } + def foo45(): scala.Int = { /* compiled code */ } + def foo46(): scala.Int = { /* compiled code */ } + def foo47(): scala.Int = { /* compiled code */ } + def foo48(): scala.Int = { /* compiled code */ } + def foo49(): scala.Int = { /* compiled code */ } + def foo50(): scala.Int = { /* compiled code */ } + def foo51(): scala.Int = { /* compiled code */ } + def foo52(): scala.Int = { /* compiled code */ } + def foo53(): scala.Int = { /* compiled code */ } + def foo54(): scala.Int = { /* compiled code */ } + def foo55(): scala.Int = { /* compiled code */ } + def foo56(): scala.Int = { /* compiled code */ } + def foo57(): scala.Int = { /* compiled code */ } + def foo58(): scala.Int = { /* compiled code */ } + def foo59(): scala.Int = { /* compiled code */ } + def foo60(): scala.Int = { /* compiled code */ } + def foo61(): scala.Int = { /* compiled code */ } + def foo62(): scala.Int = { /* compiled code */ } + def foo63(): scala.Int = { /* compiled code */ } + def foo64(): scala.Int = { /* compiled code */ } + def foo65(): scala.Int = { /* compiled code */ } + def foo66(): scala.Int = { /* compiled code */ } + def foo67(): scala.Int = { /* compiled code */ } + def foo68(): scala.Int = { /* compiled code */ } + def foo69(): scala.Int = { /* compiled code */ } + def foo70(): scala.Int = { /* compiled code */ } + def foo71(): scala.Int = { /* compiled code */ } + def foo72(): scala.Int = { /* compiled code */ } + def foo73(): scala.Int = { /* compiled code */ } + def foo74(): scala.Int = { /* compiled code */ } + def foo75(): scala.Int = { /* compiled code */ } + def foo76(): scala.Int = { /* compiled code */ } + def foo77(): scala.Int = { /* compiled code */ } + def foo78(): scala.Int = { /* compiled code */ } + def foo79(): scala.Int = { /* compiled code */ } + def foo80(): scala.Int = { /* compiled code */ } + def foo81(): scala.Int = { /* compiled code */ } + def foo82(): scala.Int = { /* compiled code */ } + def foo83(): scala.Int = { /* compiled code */ } + def foo84(): scala.Int = { /* compiled code */ } + def foo85(): scala.Int = { /* compiled code */ } + def foo86(): scala.Int = { /* compiled code */ } + def foo87(): scala.Int = { /* compiled code */ } + def foo88(): scala.Int = { /* compiled code */ } + def foo89(): scala.Int = { /* compiled code */ } + def foo90(): scala.Int = { /* compiled code */ } + def foo91(): scala.Int = { /* compiled code */ } + def foo92(): scala.Int = { /* compiled code */ } + def foo93(): scala.Int = { /* compiled code */ } + def foo94(): scala.Int = { /* compiled code */ } + def foo95(): scala.Int = { /* compiled code */ } + def foo96(): scala.Int = { /* compiled code */ } + def foo97(): scala.Int = { /* compiled code */ } + def foo98(): scala.Int = { /* compiled code */ } + def foo99(): scala.Int = { /* compiled code */ } + def foo100(): scala.Int = { /* compiled code */ } + def foo101(): scala.Int = { /* compiled code */ } + def foo102(): scala.Int = { /* compiled code */ } + def foo103(): scala.Int = { /* compiled code */ } + def foo104(): scala.Int = { /* compiled code */ } + def foo105(): scala.Int = { /* compiled code */ } + def foo106(): scala.Int = { /* compiled code */ } + def foo107(): scala.Int = { /* compiled code */ } + def foo108(): scala.Int = { /* compiled code */ } + def foo109(): scala.Int = { /* compiled code */ } + def foo110(): scala.Int = { /* compiled code */ } + def foo111(): scala.Int = { /* compiled code */ } + def foo112(): scala.Int = { /* compiled code */ } + def foo113(): scala.Int = { /* compiled code */ } + def foo114(): scala.Int = { /* compiled code */ } + def foo115(): scala.Int = { /* compiled code */ } + def foo116(): scala.Int = { /* compiled code */ } + def foo117(): scala.Int = { /* compiled code */ } + def foo118(): scala.Int = { /* compiled code */ } + def foo119(): scala.Int = { /* compiled code */ } + def foo120(): scala.Int = { /* compiled code */ } + def foo121(): scala.Int = { /* compiled code */ } + def foo122(): scala.Int = { /* compiled code */ } + def foo123(): scala.Int = { /* compiled code */ } + def foo124(): scala.Int = { /* compiled code */ } + def foo125(): scala.Int = { /* compiled code */ } + def foo126(): scala.Int = { /* compiled code */ } + def foo127(): scala.Int = { /* compiled code */ } + def foo128(): scala.Int = { /* compiled code */ } + def foo129(): scala.Int = { /* compiled code */ } + def foo130(): scala.Int = { /* compiled code */ } + def foo131(): scala.Int = { /* compiled code */ } + def foo132(): scala.Int = { /* compiled code */ } + def foo133(): scala.Int = { /* compiled code */ } + def foo134(): scala.Int = { /* compiled code */ } + def foo135(): scala.Int = { /* compiled code */ } + def foo136(): scala.Int = { /* compiled code */ } + def foo137(): scala.Int = { /* compiled code */ } + def foo138(): scala.Int = { /* compiled code */ } + def foo139(): scala.Int = { /* compiled code */ } + def foo140(): scala.Int = { /* compiled code */ } + def foo141(): scala.Int = { /* compiled code */ } + def foo142(): scala.Int = { /* compiled code */ } + def foo143(): scala.Int = { /* compiled code */ } + def foo144(): scala.Int = { /* compiled code */ } + def foo145(): scala.Int = { /* compiled code */ } + def foo146(): scala.Int = { /* compiled code */ } + def foo147(): scala.Int = { /* compiled code */ } + def foo148(): scala.Int = { /* compiled code */ } + def foo149(): scala.Int = { /* compiled code */ } + def foo150(): scala.Int = { /* compiled code */ } + def foo151(): scala.Int = { /* compiled code */ } + def foo152(): scala.Int = { /* compiled code */ } + def foo153(): scala.Int = { /* compiled code */ } + def foo154(): scala.Int = { /* compiled code */ } + def foo155(): scala.Int = { /* compiled code */ } + def foo156(): scala.Int = { /* compiled code */ } + def foo157(): scala.Int = { /* compiled code */ } + def foo158(): scala.Int = { /* compiled code */ } + def foo159(): scala.Int = { /* compiled code */ } + def foo160(): scala.Int = { /* compiled code */ } + def foo161(): scala.Int = { /* compiled code */ } + def foo162(): scala.Int = { /* compiled code */ } + def foo163(): scala.Int = { /* compiled code */ } + def foo164(): scala.Int = { /* compiled code */ } + def foo165(): scala.Int = { /* compiled code */ } + def foo166(): scala.Int = { /* compiled code */ } + def foo167(): scala.Int = { /* compiled code */ } + def foo168(): scala.Int = { /* compiled code */ } + def foo169(): scala.Int = { /* compiled code */ } + def foo170(): scala.Int = { /* compiled code */ } + def foo171(): scala.Int = { /* compiled code */ } + def foo172(): scala.Int = { /* compiled code */ } + def foo173(): scala.Int = { /* compiled code */ } + def foo174(): scala.Int = { /* compiled code */ } + def foo175(): scala.Int = { /* compiled code */ } + def foo176(): scala.Int = { /* compiled code */ } + def foo177(): scala.Int = { /* compiled code */ } + def foo178(): scala.Int = { /* compiled code */ } + def foo179(): scala.Int = { /* compiled code */ } + def foo180(): scala.Int = { /* compiled code */ } + def foo181(): scala.Int = { /* compiled code */ } + def foo182(): scala.Int = { /* compiled code */ } + def foo183(): scala.Int = { /* compiled code */ } + def foo184(): scala.Int = { /* compiled code */ } + def foo185(): scala.Int = { /* compiled code */ } + def foo186(): scala.Int = { /* compiled code */ } + def foo187(): scala.Int = { /* compiled code */ } + def foo188(): scala.Int = { /* compiled code */ } + def foo189(): scala.Int = { /* compiled code */ } + def foo190(): scala.Int = { /* compiled code */ } + def foo191(): scala.Int = { /* compiled code */ } + def foo192(): scala.Int = { /* compiled code */ } + def foo193(): scala.Int = { /* compiled code */ } + def foo194(): scala.Int = { /* compiled code */ } + def foo195(): scala.Int = { /* compiled code */ } + def foo196(): scala.Int = { /* compiled code */ } + def foo197(): scala.Int = { /* compiled code */ } + def foo198(): scala.Int = { /* compiled code */ } + def foo199(): scala.Int = { /* compiled code */ } + def foo200(): scala.Int = { /* compiled code */ } + def foo201(): scala.Int = { /* compiled code */ } + def foo202(): scala.Int = { /* compiled code */ } + def foo203(): scala.Int = { /* compiled code */ } + def foo204(): scala.Int = { /* compiled code */ } + def foo205(): scala.Int = { /* compiled code */ } + def foo206(): scala.Int = { /* compiled code */ } + def foo207(): scala.Int = { /* compiled code */ } + def foo208(): scala.Int = { /* compiled code */ } + def foo209(): scala.Int = { /* compiled code */ } + def foo210(): scala.Int = { /* compiled code */ } + def foo211(): scala.Int = { /* compiled code */ } + def foo212(): scala.Int = { /* compiled code */ } + def foo213(): scala.Int = { /* compiled code */ } + def foo214(): scala.Int = { /* compiled code */ } + def foo215(): scala.Int = { /* compiled code */ } + def foo216(): scala.Int = { /* compiled code */ } + def foo217(): scala.Int = { /* compiled code */ } + def foo218(): scala.Int = { /* compiled code */ } + def foo219(): scala.Int = { /* compiled code */ } + def foo220(): scala.Int = { /* compiled code */ } + def foo221(): scala.Int = { /* compiled code */ } + def foo222(): scala.Int = { /* compiled code */ } + def foo223(): scala.Int = { /* compiled code */ } + def foo224(): scala.Int = { /* compiled code */ } + def foo225(): scala.Int = { /* compiled code */ } + def foo226(): scala.Int = { /* compiled code */ } + def foo227(): scala.Int = { /* compiled code */ } + def foo228(): scala.Int = { /* compiled code */ } + def foo229(): scala.Int = { /* compiled code */ } + def foo230(): scala.Int = { /* compiled code */ } + def foo231(): scala.Int = { /* compiled code */ } + def foo232(): scala.Int = { /* compiled code */ } + def foo233(): scala.Int = { /* compiled code */ } + def foo234(): scala.Int = { /* compiled code */ } + def foo235(): scala.Int = { /* compiled code */ } + def foo236(): scala.Int = { /* compiled code */ } + def foo237(): scala.Int = { /* compiled code */ } + def foo238(): scala.Int = { /* compiled code */ } + def foo239(): scala.Int = { /* compiled code */ } + def foo240(): scala.Int = { /* compiled code */ } + def foo241(): scala.Int = { /* compiled code */ } + def foo242(): scala.Int = { /* compiled code */ } + def foo243(): scala.Int = { /* compiled code */ } + def foo244(): scala.Int = { /* compiled code */ } + def foo245(): scala.Int = { /* compiled code */ } + def foo246(): scala.Int = { /* compiled code */ } + def foo247(): scala.Int = { /* compiled code */ } + def foo248(): scala.Int = { /* compiled code */ } + def foo249(): scala.Int = { /* compiled code */ } + def foo250(): scala.Int = { /* compiled code */ } + def foo251(): scala.Int = { /* compiled code */ } + def foo252(): scala.Int = { /* compiled code */ } + def foo253(): scala.Int = { /* compiled code */ } + def foo254(): scala.Int = { /* compiled code */ } + def foo255(): scala.Int = { /* compiled code */ } + def foo256(): scala.Int = { /* compiled code */ } + def foo257(): scala.Int = { /* compiled code */ } + def foo258(): scala.Int = { /* compiled code */ } + def foo259(): scala.Int = { /* compiled code */ } + def foo260(): scala.Int = { /* compiled code */ } + def foo261(): scala.Int = { /* compiled code */ } + def foo262(): scala.Int = { /* compiled code */ } + def foo263(): scala.Int = { /* compiled code */ } + def foo264(): scala.Int = { /* compiled code */ } + def foo265(): scala.Int = { /* compiled code */ } + def foo266(): scala.Int = { /* compiled code */ } + def foo267(): scala.Int = { /* compiled code */ } + def foo268(): scala.Int = { /* compiled code */ } + def foo269(): scala.Int = { /* compiled code */ } + def foo270(): scala.Int = { /* compiled code */ } + def foo271(): scala.Int = { /* compiled code */ } + def foo272(): scala.Int = { /* compiled code */ } + def foo273(): scala.Int = { /* compiled code */ } + def foo274(): scala.Int = { /* compiled code */ } + def foo275(): scala.Int = { /* compiled code */ } + def foo276(): scala.Int = { /* compiled code */ } + def foo277(): scala.Int = { /* compiled code */ } + def foo278(): scala.Int = { /* compiled code */ } + def foo279(): scala.Int = { /* compiled code */ } + def foo280(): scala.Int = { /* compiled code */ } + def foo281(): scala.Int = { /* compiled code */ } + def foo282(): scala.Int = { /* compiled code */ } + def foo283(): scala.Int = { /* compiled code */ } + def foo284(): scala.Int = { /* compiled code */ } + def foo285(): scala.Int = { /* compiled code */ } + def foo286(): scala.Int = { /* compiled code */ } + def foo287(): scala.Int = { /* compiled code */ } + def foo288(): scala.Int = { /* compiled code */ } + def foo289(): scala.Int = { /* compiled code */ } + def foo290(): scala.Int = { /* compiled code */ } + def foo291(): scala.Int = { /* compiled code */ } + def foo292(): scala.Int = { /* compiled code */ } + def foo293(): scala.Int = { /* compiled code */ } + def foo294(): scala.Int = { /* compiled code */ } + def foo295(): scala.Int = { /* compiled code */ } + def foo296(): scala.Int = { /* compiled code */ } + def foo297(): scala.Int = { /* compiled code */ } + def foo298(): scala.Int = { /* compiled code */ } + def foo299(): scala.Int = { /* compiled code */ } + def foo300(): scala.Int = { /* compiled code */ } + def foo301(): scala.Int = { /* compiled code */ } + def foo302(): scala.Int = { /* compiled code */ } + def foo303(): scala.Int = { /* compiled code */ } + def foo304(): scala.Int = { /* compiled code */ } + def foo305(): scala.Int = { /* compiled code */ } + def foo306(): scala.Int = { /* compiled code */ } + def foo307(): scala.Int = { /* compiled code */ } + def foo308(): scala.Int = { /* compiled code */ } + def foo309(): scala.Int = { /* compiled code */ } + def foo310(): scala.Int = { /* compiled code */ } + def foo311(): scala.Int = { /* compiled code */ } + def foo312(): scala.Int = { /* compiled code */ } + def foo313(): scala.Int = { /* compiled code */ } + def foo314(): scala.Int = { /* compiled code */ } + def foo315(): scala.Int = { /* compiled code */ } + def foo316(): scala.Int = { /* compiled code */ } + def foo317(): scala.Int = { /* compiled code */ } + def foo318(): scala.Int = { /* compiled code */ } + def foo319(): scala.Int = { /* compiled code */ } + def foo320(): scala.Int = { /* compiled code */ } + def foo321(): scala.Int = { /* compiled code */ } + def foo322(): scala.Int = { /* compiled code */ } + def foo323(): scala.Int = { /* compiled code */ } + def foo324(): scala.Int = { /* compiled code */ } + def foo325(): scala.Int = { /* compiled code */ } + def foo326(): scala.Int = { /* compiled code */ } + def foo327(): scala.Int = { /* compiled code */ } + def foo328(): scala.Int = { /* compiled code */ } + def foo329(): scala.Int = { /* compiled code */ } + def foo330(): scala.Int = { /* compiled code */ } + def foo331(): scala.Int = { /* compiled code */ } + def foo332(): scala.Int = { /* compiled code */ } + def foo333(): scala.Int = { /* compiled code */ } + def foo334(): scala.Int = { /* compiled code */ } + def foo335(): scala.Int = { /* compiled code */ } + def foo336(): scala.Int = { /* compiled code */ } + def foo337(): scala.Int = { /* compiled code */ } + def foo338(): scala.Int = { /* compiled code */ } + def foo339(): scala.Int = { /* compiled code */ } + def foo340(): scala.Int = { /* compiled code */ } + def foo341(): scala.Int = { /* compiled code */ } + def foo342(): scala.Int = { /* compiled code */ } + def foo343(): scala.Int = { /* compiled code */ } + def foo344(): scala.Int = { /* compiled code */ } + def foo345(): scala.Int = { /* compiled code */ } + def foo346(): scala.Int = { /* compiled code */ } + def foo347(): scala.Int = { /* compiled code */ } + def foo348(): scala.Int = { /* compiled code */ } + def foo349(): scala.Int = { /* compiled code */ } + def foo350(): scala.Int = { /* compiled code */ } + def foo351(): scala.Int = { /* compiled code */ } + def foo352(): scala.Int = { /* compiled code */ } + def foo353(): scala.Int = { /* compiled code */ } + def foo354(): scala.Int = { /* compiled code */ } + def foo355(): scala.Int = { /* compiled code */ } + def foo356(): scala.Int = { /* compiled code */ } + def foo357(): scala.Int = { /* compiled code */ } + def foo358(): scala.Int = { /* compiled code */ } + def foo359(): scala.Int = { /* compiled code */ } + def foo360(): scala.Int = { /* compiled code */ } + def foo361(): scala.Int = { /* compiled code */ } + def foo362(): scala.Int = { /* compiled code */ } + def foo363(): scala.Int = { /* compiled code */ } + def foo364(): scala.Int = { /* compiled code */ } + def foo365(): scala.Int = { /* compiled code */ } + def foo366(): scala.Int = { /* compiled code */ } + def foo367(): scala.Int = { /* compiled code */ } + def foo368(): scala.Int = { /* compiled code */ } + def foo369(): scala.Int = { /* compiled code */ } + def foo370(): scala.Int = { /* compiled code */ } + def foo371(): scala.Int = { /* compiled code */ } + def foo372(): scala.Int = { /* compiled code */ } + def foo373(): scala.Int = { /* compiled code */ } + def foo374(): scala.Int = { /* compiled code */ } + def foo375(): scala.Int = { /* compiled code */ } + def foo376(): scala.Int = { /* compiled code */ } + def foo377(): scala.Int = { /* compiled code */ } + def foo378(): scala.Int = { /* compiled code */ } + def foo379(): scala.Int = { /* compiled code */ } + def foo380(): scala.Int = { /* compiled code */ } + def foo381(): scala.Int = { /* compiled code */ } + def foo382(): scala.Int = { /* compiled code */ } + def foo383(): scala.Int = { /* compiled code */ } + def foo384(): scala.Int = { /* compiled code */ } + def foo385(): scala.Int = { /* compiled code */ } + def foo386(): scala.Int = { /* compiled code */ } + def foo387(): scala.Int = { /* compiled code */ } + def foo388(): scala.Int = { /* compiled code */ } + def foo389(): scala.Int = { /* compiled code */ } + def foo390(): scala.Int = { /* compiled code */ } + def foo391(): scala.Int = { /* compiled code */ } + def foo392(): scala.Int = { /* compiled code */ } + def foo393(): scala.Int = { /* compiled code */ } + def foo394(): scala.Int = { /* compiled code */ } + def foo395(): scala.Int = { /* compiled code */ } + def foo396(): scala.Int = { /* compiled code */ } + def foo397(): scala.Int = { /* compiled code */ } + def foo398(): scala.Int = { /* compiled code */ } + def foo399(): scala.Int = { /* compiled code */ } + def foo400(): scala.Int = { /* compiled code */ } + def foo401(): scala.Int = { /* compiled code */ } + def foo402(): scala.Int = { /* compiled code */ } + def foo403(): scala.Int = { /* compiled code */ } + def foo404(): scala.Int = { /* compiled code */ } + def foo405(): scala.Int = { /* compiled code */ } + def foo406(): scala.Int = { /* compiled code */ } + def foo407(): scala.Int = { /* compiled code */ } + def foo408(): scala.Int = { /* compiled code */ } + def foo409(): scala.Int = { /* compiled code */ } + def foo410(): scala.Int = { /* compiled code */ } + def foo411(): scala.Int = { /* compiled code */ } + def foo412(): scala.Int = { /* compiled code */ } + def foo413(): scala.Int = { /* compiled code */ } + def foo414(): scala.Int = { /* compiled code */ } + def foo415(): scala.Int = { /* compiled code */ } + def foo416(): scala.Int = { /* compiled code */ } + def foo417(): scala.Int = { /* compiled code */ } + def foo418(): scala.Int = { /* compiled code */ } + def foo419(): scala.Int = { /* compiled code */ } + def foo420(): scala.Int = { /* compiled code */ } + def foo421(): scala.Int = { /* compiled code */ } + def foo422(): scala.Int = { /* compiled code */ } + def foo423(): scala.Int = { /* compiled code */ } + def foo424(): scala.Int = { /* compiled code */ } + def foo425(): scala.Int = { /* compiled code */ } + def foo426(): scala.Int = { /* compiled code */ } + def foo427(): scala.Int = { /* compiled code */ } + def foo428(): scala.Int = { /* compiled code */ } + def foo429(): scala.Int = { /* compiled code */ } + def foo430(): scala.Int = { /* compiled code */ } + def foo431(): scala.Int = { /* compiled code */ } + def foo432(): scala.Int = { /* compiled code */ } + def foo433(): scala.Int = { /* compiled code */ } + def foo434(): scala.Int = { /* compiled code */ } + def foo435(): scala.Int = { /* compiled code */ } + def foo436(): scala.Int = { /* compiled code */ } + def foo437(): scala.Int = { /* compiled code */ } + def foo438(): scala.Int = { /* compiled code */ } + def foo439(): scala.Int = { /* compiled code */ } + def foo440(): scala.Int = { /* compiled code */ } + def foo441(): scala.Int = { /* compiled code */ } + def foo442(): scala.Int = { /* compiled code */ } + def foo443(): scala.Int = { /* compiled code */ } + def foo444(): scala.Int = { /* compiled code */ } + def foo445(): scala.Int = { /* compiled code */ } + def foo446(): scala.Int = { /* compiled code */ } + def foo447(): scala.Int = { /* compiled code */ } + def foo448(): scala.Int = { /* compiled code */ } + def foo449(): scala.Int = { /* compiled code */ } + def foo450(): scala.Int = { /* compiled code */ } + def foo451(): scala.Int = { /* compiled code */ } + def foo452(): scala.Int = { /* compiled code */ } + def foo453(): scala.Int = { /* compiled code */ } + def foo454(): scala.Int = { /* compiled code */ } + def foo455(): scala.Int = { /* compiled code */ } + def foo456(): scala.Int = { /* compiled code */ } + def foo457(): scala.Int = { /* compiled code */ } + def foo458(): scala.Int = { /* compiled code */ } + def foo459(): scala.Int = { /* compiled code */ } + def foo460(): scala.Int = { /* compiled code */ } + def foo461(): scala.Int = { /* compiled code */ } + def foo462(): scala.Int = { /* compiled code */ } + def foo463(): scala.Int = { /* compiled code */ } + def foo464(): scala.Int = { /* compiled code */ } + def foo465(): scala.Int = { /* compiled code */ } + def foo466(): scala.Int = { /* compiled code */ } + def foo467(): scala.Int = { /* compiled code */ } + def foo468(): scala.Int = { /* compiled code */ } + def foo469(): scala.Int = { /* compiled code */ } + def foo470(): scala.Int = { /* compiled code */ } + def foo471(): scala.Int = { /* compiled code */ } + def foo472(): scala.Int = { /* compiled code */ } + def foo473(): scala.Int = { /* compiled code */ } + def foo474(): scala.Int = { /* compiled code */ } + def foo475(): scala.Int = { /* compiled code */ } + def foo476(): scala.Int = { /* compiled code */ } + def foo477(): scala.Int = { /* compiled code */ } + def foo478(): scala.Int = { /* compiled code */ } + def foo479(): scala.Int = { /* compiled code */ } + def foo480(): scala.Int = { /* compiled code */ } + def foo481(): scala.Int = { /* compiled code */ } + def foo482(): scala.Int = { /* compiled code */ } + def foo483(): scala.Int = { /* compiled code */ } + def foo484(): scala.Int = { /* compiled code */ } + def foo485(): scala.Int = { /* compiled code */ } + def foo486(): scala.Int = { /* compiled code */ } + def foo487(): scala.Int = { /* compiled code */ } + def foo488(): scala.Int = { /* compiled code */ } + def foo489(): scala.Int = { /* compiled code */ } + def foo490(): scala.Int = { /* compiled code */ } + def foo491(): scala.Int = { /* compiled code */ } + def foo492(): scala.Int = { /* compiled code */ } + def foo493(): scala.Int = { /* compiled code */ } + def foo494(): scala.Int = { /* compiled code */ } + def foo495(): scala.Int = { /* compiled code */ } + def foo496(): scala.Int = { /* compiled code */ } + def foo497(): scala.Int = { /* compiled code */ } + def foo498(): scala.Int = { /* compiled code */ } + def foo499(): scala.Int = { /* compiled code */ } + def foo500(): scala.Int = { /* compiled code */ } + def foo501(): scala.Int = { /* compiled code */ } + def foo502(): scala.Int = { /* compiled code */ } + def foo503(): scala.Int = { /* compiled code */ } + def foo504(): scala.Int = { /* compiled code */ } + def foo505(): scala.Int = { /* compiled code */ } + def foo506(): scala.Int = { /* compiled code */ } + def foo507(): scala.Int = { /* compiled code */ } + def foo508(): scala.Int = { /* compiled code */ } + def foo509(): scala.Int = { /* compiled code */ } + def foo510(): scala.Int = { /* compiled code */ } + def foo511(): scala.Int = { /* compiled code */ } + def foo512(): scala.Int = { /* compiled code */ } + def foo513(): scala.Int = { /* compiled code */ } + def foo514(): scala.Int = { /* compiled code */ } + def foo515(): scala.Int = { /* compiled code */ } + def foo516(): scala.Int = { /* compiled code */ } + def foo517(): scala.Int = { /* compiled code */ } + def foo518(): scala.Int = { /* compiled code */ } + def foo519(): scala.Int = { /* compiled code */ } + def foo520(): scala.Int = { /* compiled code */ } + def foo521(): scala.Int = { /* compiled code */ } + def foo522(): scala.Int = { /* compiled code */ } + def foo523(): scala.Int = { /* compiled code */ } + def foo524(): scala.Int = { /* compiled code */ } + def foo525(): scala.Int = { /* compiled code */ } + def foo526(): scala.Int = { /* compiled code */ } + def foo527(): scala.Int = { /* compiled code */ } + def foo528(): scala.Int = { /* compiled code */ } + def foo529(): scala.Int = { /* compiled code */ } + def foo530(): scala.Int = { /* compiled code */ } + def foo531(): scala.Int = { /* compiled code */ } + def foo532(): scala.Int = { /* compiled code */ } + def foo533(): scala.Int = { /* compiled code */ } + def foo534(): scala.Int = { /* compiled code */ } + def foo535(): scala.Int = { /* compiled code */ } + def foo536(): scala.Int = { /* compiled code */ } + def foo537(): scala.Int = { /* compiled code */ } + def foo538(): scala.Int = { /* compiled code */ } + def foo539(): scala.Int = { /* compiled code */ } + def foo540(): scala.Int = { /* compiled code */ } + def foo541(): scala.Int = { /* compiled code */ } + def foo542(): scala.Int = { /* compiled code */ } + def foo543(): scala.Int = { /* compiled code */ } + def foo544(): scala.Int = { /* compiled code */ } + def foo545(): scala.Int = { /* compiled code */ } + def foo546(): scala.Int = { /* compiled code */ } + def foo547(): scala.Int = { /* compiled code */ } + def foo548(): scala.Int = { /* compiled code */ } + def foo549(): scala.Int = { /* compiled code */ } + def foo550(): scala.Int = { /* compiled code */ } + def foo551(): scala.Int = { /* compiled code */ } + def foo552(): scala.Int = { /* compiled code */ } + def foo553(): scala.Int = { /* compiled code */ } + def foo554(): scala.Int = { /* compiled code */ } + def foo555(): scala.Int = { /* compiled code */ } + def foo556(): scala.Int = { /* compiled code */ } + def foo557(): scala.Int = { /* compiled code */ } + def foo558(): scala.Int = { /* compiled code */ } + def foo559(): scala.Int = { /* compiled code */ } + def foo560(): scala.Int = { /* compiled code */ } + def foo561(): scala.Int = { /* compiled code */ } + def foo562(): scala.Int = { /* compiled code */ } + def foo563(): scala.Int = { /* compiled code */ } + def foo564(): scala.Int = { /* compiled code */ } + def foo565(): scala.Int = { /* compiled code */ } + def foo566(): scala.Int = { /* compiled code */ } + def foo567(): scala.Int = { /* compiled code */ } + def foo568(): scala.Int = { /* compiled code */ } + def foo569(): scala.Int = { /* compiled code */ } + def foo570(): scala.Int = { /* compiled code */ } + def foo571(): scala.Int = { /* compiled code */ } + def foo572(): scala.Int = { /* compiled code */ } + def foo573(): scala.Int = { /* compiled code */ } + def foo574(): scala.Int = { /* compiled code */ } + def foo575(): scala.Int = { /* compiled code */ } + def foo576(): scala.Int = { /* compiled code */ } + def foo577(): scala.Int = { /* compiled code */ } + def foo578(): scala.Int = { /* compiled code */ } + def foo579(): scala.Int = { /* compiled code */ } + def foo580(): scala.Int = { /* compiled code */ } + def foo581(): scala.Int = { /* compiled code */ } + def foo582(): scala.Int = { /* compiled code */ } + def foo583(): scala.Int = { /* compiled code */ } + def foo584(): scala.Int = { /* compiled code */ } + def foo585(): scala.Int = { /* compiled code */ } + def foo586(): scala.Int = { /* compiled code */ } + def foo587(): scala.Int = { /* compiled code */ } + def foo588(): scala.Int = { /* compiled code */ } + def foo589(): scala.Int = { /* compiled code */ } + def foo590(): scala.Int = { /* compiled code */ } + def foo591(): scala.Int = { /* compiled code */ } + def foo592(): scala.Int = { /* compiled code */ } + def foo593(): scala.Int = { /* compiled code */ } + def foo594(): scala.Int = { /* compiled code */ } + def foo595(): scala.Int = { /* compiled code */ } + def foo596(): scala.Int = { /* compiled code */ } + def foo597(): scala.Int = { /* compiled code */ } + def foo598(): scala.Int = { /* compiled code */ } + def foo599(): scala.Int = { /* compiled code */ } + def foo600(): scala.Int = { /* compiled code */ } + def foo601(): scala.Int = { /* compiled code */ } + def foo602(): scala.Int = { /* compiled code */ } + def foo603(): scala.Int = { /* compiled code */ } + def foo604(): scala.Int = { /* compiled code */ } + def foo605(): scala.Int = { /* compiled code */ } + def foo606(): scala.Int = { /* compiled code */ } + def foo607(): scala.Int = { /* compiled code */ } + def foo608(): scala.Int = { /* compiled code */ } + def foo609(): scala.Int = { /* compiled code */ } + def foo610(): scala.Int = { /* compiled code */ } + def foo611(): scala.Int = { /* compiled code */ } + def foo612(): scala.Int = { /* compiled code */ } + def foo613(): scala.Int = { /* compiled code */ } + def foo614(): scala.Int = { /* compiled code */ } + def foo615(): scala.Int = { /* compiled code */ } + def foo616(): scala.Int = { /* compiled code */ } + def foo617(): scala.Int = { /* compiled code */ } + def foo618(): scala.Int = { /* compiled code */ } + def foo619(): scala.Int = { /* compiled code */ } + def foo620(): scala.Int = { /* compiled code */ } + def foo621(): scala.Int = { /* compiled code */ } + def foo622(): scala.Int = { /* compiled code */ } + def foo623(): scala.Int = { /* compiled code */ } + def foo624(): scala.Int = { /* compiled code */ } + def foo625(): scala.Int = { /* compiled code */ } + def foo626(): scala.Int = { /* compiled code */ } + def foo627(): scala.Int = { /* compiled code */ } + def foo628(): scala.Int = { /* compiled code */ } + def foo629(): scala.Int = { /* compiled code */ } + def foo630(): scala.Int = { /* compiled code */ } + def foo631(): scala.Int = { /* compiled code */ } + def foo632(): scala.Int = { /* compiled code */ } + def foo633(): scala.Int = { /* compiled code */ } + def foo634(): scala.Int = { /* compiled code */ } + def foo635(): scala.Int = { /* compiled code */ } + def foo636(): scala.Int = { /* compiled code */ } + def foo637(): scala.Int = { /* compiled code */ } + def foo638(): scala.Int = { /* compiled code */ } + def foo639(): scala.Int = { /* compiled code */ } + def foo640(): scala.Int = { /* compiled code */ } + def foo641(): scala.Int = { /* compiled code */ } + def foo642(): scala.Int = { /* compiled code */ } + def foo643(): scala.Int = { /* compiled code */ } + def foo644(): scala.Int = { /* compiled code */ } + def foo645(): scala.Int = { /* compiled code */ } + def foo646(): scala.Int = { /* compiled code */ } + def foo647(): scala.Int = { /* compiled code */ } + def foo648(): scala.Int = { /* compiled code */ } + def foo649(): scala.Int = { /* compiled code */ } + def foo650(): scala.Int = { /* compiled code */ } + def foo651(): scala.Int = { /* compiled code */ } + def foo652(): scala.Int = { /* compiled code */ } + def foo653(): scala.Int = { /* compiled code */ } + def foo654(): scala.Int = { /* compiled code */ } + def foo655(): scala.Int = { /* compiled code */ } + def foo656(): scala.Int = { /* compiled code */ } + def foo657(): scala.Int = { /* compiled code */ } + def foo658(): scala.Int = { /* compiled code */ } + def foo659(): scala.Int = { /* compiled code */ } + def foo660(): scala.Int = { /* compiled code */ } + def foo661(): scala.Int = { /* compiled code */ } + def foo662(): scala.Int = { /* compiled code */ } + def foo663(): scala.Int = { /* compiled code */ } + def foo664(): scala.Int = { /* compiled code */ } + def foo665(): scala.Int = { /* compiled code */ } + def foo666(): scala.Int = { /* compiled code */ } + def foo667(): scala.Int = { /* compiled code */ } + def foo668(): scala.Int = { /* compiled code */ } + def foo669(): scala.Int = { /* compiled code */ } + def foo670(): scala.Int = { /* compiled code */ } + def foo671(): scala.Int = { /* compiled code */ } + def foo672(): scala.Int = { /* compiled code */ } + def foo673(): scala.Int = { /* compiled code */ } + def foo674(): scala.Int = { /* compiled code */ } + def foo675(): scala.Int = { /* compiled code */ } + def foo676(): scala.Int = { /* compiled code */ } + def foo677(): scala.Int = { /* compiled code */ } + def foo678(): scala.Int = { /* compiled code */ } + def foo679(): scala.Int = { /* compiled code */ } + def foo680(): scala.Int = { /* compiled code */ } + def foo681(): scala.Int = { /* compiled code */ } + def foo682(): scala.Int = { /* compiled code */ } + def foo683(): scala.Int = { /* compiled code */ } + def foo684(): scala.Int = { /* compiled code */ } + def foo685(): scala.Int = { /* compiled code */ } + def foo686(): scala.Int = { /* compiled code */ } + def foo687(): scala.Int = { /* compiled code */ } + def foo688(): scala.Int = { /* compiled code */ } + def foo689(): scala.Int = { /* compiled code */ } + def foo690(): scala.Int = { /* compiled code */ } + def foo691(): scala.Int = { /* compiled code */ } + def foo692(): scala.Int = { /* compiled code */ } + def foo693(): scala.Int = { /* compiled code */ } + def foo694(): scala.Int = { /* compiled code */ } + def foo695(): scala.Int = { /* compiled code */ } + def foo696(): scala.Int = { /* compiled code */ } + def foo697(): scala.Int = { /* compiled code */ } + def foo698(): scala.Int = { /* compiled code */ } + def foo699(): scala.Int = { /* compiled code */ } + def foo700(): scala.Int = { /* compiled code */ } + def foo701(): scala.Int = { /* compiled code */ } + def foo702(): scala.Int = { /* compiled code */ } + def foo703(): scala.Int = { /* compiled code */ } + def foo704(): scala.Int = { /* compiled code */ } + def foo705(): scala.Int = { /* compiled code */ } + def foo706(): scala.Int = { /* compiled code */ } + def foo707(): scala.Int = { /* compiled code */ } + def foo708(): scala.Int = { /* compiled code */ } + def foo709(): scala.Int = { /* compiled code */ } + def foo710(): scala.Int = { /* compiled code */ } + def foo711(): scala.Int = { /* compiled code */ } + def foo712(): scala.Int = { /* compiled code */ } + def foo713(): scala.Int = { /* compiled code */ } + def foo714(): scala.Int = { /* compiled code */ } + def foo715(): scala.Int = { /* compiled code */ } + def foo716(): scala.Int = { /* compiled code */ } + def foo717(): scala.Int = { /* compiled code */ } + def foo718(): scala.Int = { /* compiled code */ } + def foo719(): scala.Int = { /* compiled code */ } + def foo720(): scala.Int = { /* compiled code */ } + def foo721(): scala.Int = { /* compiled code */ } + def foo722(): scala.Int = { /* compiled code */ } + def foo723(): scala.Int = { /* compiled code */ } + def foo724(): scala.Int = { /* compiled code */ } + def foo725(): scala.Int = { /* compiled code */ } + def foo726(): scala.Int = { /* compiled code */ } + def foo727(): scala.Int = { /* compiled code */ } + def foo728(): scala.Int = { /* compiled code */ } + def foo729(): scala.Int = { /* compiled code */ } + def foo730(): scala.Int = { /* compiled code */ } + def foo731(): scala.Int = { /* compiled code */ } + def foo732(): scala.Int = { /* compiled code */ } + def foo733(): scala.Int = { /* compiled code */ } + def foo734(): scala.Int = { /* compiled code */ } + def foo735(): scala.Int = { /* compiled code */ } + def foo736(): scala.Int = { /* compiled code */ } + def foo737(): scala.Int = { /* compiled code */ } + def foo738(): scala.Int = { /* compiled code */ } + def foo739(): scala.Int = { /* compiled code */ } + def foo740(): scala.Int = { /* compiled code */ } + def foo741(): scala.Int = { /* compiled code */ } + def foo742(): scala.Int = { /* compiled code */ } + def foo743(): scala.Int = { /* compiled code */ } + def foo744(): scala.Int = { /* compiled code */ } + def foo745(): scala.Int = { /* compiled code */ } + def foo746(): scala.Int = { /* compiled code */ } + def foo747(): scala.Int = { /* compiled code */ } + def foo748(): scala.Int = { /* compiled code */ } + def foo749(): scala.Int = { /* compiled code */ } + def foo750(): scala.Int = { /* compiled code */ } + def foo751(): scala.Int = { /* compiled code */ } + def foo752(): scala.Int = { /* compiled code */ } + def foo753(): scala.Int = { /* compiled code */ } + def foo754(): scala.Int = { /* compiled code */ } + def foo755(): scala.Int = { /* compiled code */ } + def foo756(): scala.Int = { /* compiled code */ } + def foo757(): scala.Int = { /* compiled code */ } + def foo758(): scala.Int = { /* compiled code */ } + def foo759(): scala.Int = { /* compiled code */ } + def foo760(): scala.Int = { /* compiled code */ } + def foo761(): scala.Int = { /* compiled code */ } + def foo762(): scala.Int = { /* compiled code */ } + def foo763(): scala.Int = { /* compiled code */ } + def foo764(): scala.Int = { /* compiled code */ } + def foo765(): scala.Int = { /* compiled code */ } + def foo766(): scala.Int = { /* compiled code */ } + def foo767(): scala.Int = { /* compiled code */ } + def foo768(): scala.Int = { /* compiled code */ } + def foo769(): scala.Int = { /* compiled code */ } + def foo770(): scala.Int = { /* compiled code */ } + def foo771(): scala.Int = { /* compiled code */ } + def foo772(): scala.Int = { /* compiled code */ } + def foo773(): scala.Int = { /* compiled code */ } + def foo774(): scala.Int = { /* compiled code */ } + def foo775(): scala.Int = { /* compiled code */ } + def foo776(): scala.Int = { /* compiled code */ } + def foo777(): scala.Int = { /* compiled code */ } + def foo778(): scala.Int = { /* compiled code */ } + def foo779(): scala.Int = { /* compiled code */ } + def foo780(): scala.Int = { /* compiled code */ } + def foo781(): scala.Int = { /* compiled code */ } + def foo782(): scala.Int = { /* compiled code */ } + def foo783(): scala.Int = { /* compiled code */ } + def foo784(): scala.Int = { /* compiled code */ } + def foo785(): scala.Int = { /* compiled code */ } + def foo786(): scala.Int = { /* compiled code */ } + def foo787(): scala.Int = { /* compiled code */ } + def foo788(): scala.Int = { /* compiled code */ } + def foo789(): scala.Int = { /* compiled code */ } + def foo790(): scala.Int = { /* compiled code */ } + def foo791(): scala.Int = { /* compiled code */ } + def foo792(): scala.Int = { /* compiled code */ } + def foo793(): scala.Int = { /* compiled code */ } + def foo794(): scala.Int = { /* compiled code */ } + def foo795(): scala.Int = { /* compiled code */ } + def foo796(): scala.Int = { /* compiled code */ } + def foo797(): scala.Int = { /* compiled code */ } + def foo798(): scala.Int = { /* compiled code */ } + def foo799(): scala.Int = { /* compiled code */ } + def foo800(): scala.Int = { /* compiled code */ } + def foo801(): scala.Int = { /* compiled code */ } + def foo802(): scala.Int = { /* compiled code */ } + def foo803(): scala.Int = { /* compiled code */ } + def foo804(): scala.Int = { /* compiled code */ } + def foo805(): scala.Int = { /* compiled code */ } + def foo806(): scala.Int = { /* compiled code */ } + def foo807(): scala.Int = { /* compiled code */ } + def foo808(): scala.Int = { /* compiled code */ } + def foo809(): scala.Int = { /* compiled code */ } + def foo810(): scala.Int = { /* compiled code */ } + def foo811(): scala.Int = { /* compiled code */ } + def foo812(): scala.Int = { /* compiled code */ } + def foo813(): scala.Int = { /* compiled code */ } + def foo814(): scala.Int = { /* compiled code */ } + def foo815(): scala.Int = { /* compiled code */ } + def foo816(): scala.Int = { /* compiled code */ } + def foo817(): scala.Int = { /* compiled code */ } + def foo818(): scala.Int = { /* compiled code */ } + def foo819(): scala.Int = { /* compiled code */ } + def foo820(): scala.Int = { /* compiled code */ } + def foo821(): scala.Int = { /* compiled code */ } + def foo822(): scala.Int = { /* compiled code */ } + def foo823(): scala.Int = { /* compiled code */ } + def foo824(): scala.Int = { /* compiled code */ } + def foo825(): scala.Int = { /* compiled code */ } + def foo826(): scala.Int = { /* compiled code */ } + def foo827(): scala.Int = { /* compiled code */ } + def foo828(): scala.Int = { /* compiled code */ } + def foo829(): scala.Int = { /* compiled code */ } + def foo830(): scala.Int = { /* compiled code */ } + def foo831(): scala.Int = { /* compiled code */ } + def foo832(): scala.Int = { /* compiled code */ } + def foo833(): scala.Int = { /* compiled code */ } + def foo834(): scala.Int = { /* compiled code */ } + def foo835(): scala.Int = { /* compiled code */ } + def foo836(): scala.Int = { /* compiled code */ } + def foo837(): scala.Int = { /* compiled code */ } + def foo838(): scala.Int = { /* compiled code */ } + def foo839(): scala.Int = { /* compiled code */ } + def foo840(): scala.Int = { /* compiled code */ } + def foo841(): scala.Int = { /* compiled code */ } + def foo842(): scala.Int = { /* compiled code */ } + def foo843(): scala.Int = { /* compiled code */ } + def foo844(): scala.Int = { /* compiled code */ } + def foo845(): scala.Int = { /* compiled code */ } + def foo846(): scala.Int = { /* compiled code */ } + def foo847(): scala.Int = { /* compiled code */ } + def foo848(): scala.Int = { /* compiled code */ } + def foo849(): scala.Int = { /* compiled code */ } + def foo850(): scala.Int = { /* compiled code */ } + def foo851(): scala.Int = { /* compiled code */ } + def foo852(): scala.Int = { /* compiled code */ } + def foo853(): scala.Int = { /* compiled code */ } + def foo854(): scala.Int = { /* compiled code */ } + def foo855(): scala.Int = { /* compiled code */ } + def foo856(): scala.Int = { /* compiled code */ } + def foo857(): scala.Int = { /* compiled code */ } + def foo858(): scala.Int = { /* compiled code */ } + def foo859(): scala.Int = { /* compiled code */ } + def foo860(): scala.Int = { /* compiled code */ } + def foo861(): scala.Int = { /* compiled code */ } + def foo862(): scala.Int = { /* compiled code */ } + def foo863(): scala.Int = { /* compiled code */ } + def foo864(): scala.Int = { /* compiled code */ } + def foo865(): scala.Int = { /* compiled code */ } + def foo866(): scala.Int = { /* compiled code */ } + def foo867(): scala.Int = { /* compiled code */ } + def foo868(): scala.Int = { /* compiled code */ } + def foo869(): scala.Int = { /* compiled code */ } + def foo870(): scala.Int = { /* compiled code */ } + def foo871(): scala.Int = { /* compiled code */ } + def foo872(): scala.Int = { /* compiled code */ } + def foo873(): scala.Int = { /* compiled code */ } + def foo874(): scala.Int = { /* compiled code */ } + def foo875(): scala.Int = { /* compiled code */ } + def foo876(): scala.Int = { /* compiled code */ } + def foo877(): scala.Int = { /* compiled code */ } + def foo878(): scala.Int = { /* compiled code */ } + def foo879(): scala.Int = { /* compiled code */ } + def foo880(): scala.Int = { /* compiled code */ } + def foo881(): scala.Int = { /* compiled code */ } + def foo882(): scala.Int = { /* compiled code */ } + def foo883(): scala.Int = { /* compiled code */ } + def foo884(): scala.Int = { /* compiled code */ } + def foo885(): scala.Int = { /* compiled code */ } + def foo886(): scala.Int = { /* compiled code */ } + def foo887(): scala.Int = { /* compiled code */ } + def foo888(): scala.Int = { /* compiled code */ } + def foo889(): scala.Int = { /* compiled code */ } + def foo890(): scala.Int = { /* compiled code */ } + def foo891(): scala.Int = { /* compiled code */ } + def foo892(): scala.Int = { /* compiled code */ } + def foo893(): scala.Int = { /* compiled code */ } + def foo894(): scala.Int = { /* compiled code */ } + def foo895(): scala.Int = { /* compiled code */ } + def foo896(): scala.Int = { /* compiled code */ } + def foo897(): scala.Int = { /* compiled code */ } + def foo898(): scala.Int = { /* compiled code */ } + def foo899(): scala.Int = { /* compiled code */ } + def foo900(): scala.Int = { /* compiled code */ } + def foo901(): scala.Int = { /* compiled code */ } + def foo902(): scala.Int = { /* compiled code */ } + def foo903(): scala.Int = { /* compiled code */ } + def foo904(): scala.Int = { /* compiled code */ } + def foo905(): scala.Int = { /* compiled code */ } + def foo906(): scala.Int = { /* compiled code */ } + def foo907(): scala.Int = { /* compiled code */ } + def foo908(): scala.Int = { /* compiled code */ } + def foo909(): scala.Int = { /* compiled code */ } + def foo910(): scala.Int = { /* compiled code */ } + def foo911(): scala.Int = { /* compiled code */ } + def foo912(): scala.Int = { /* compiled code */ } + def foo913(): scala.Int = { /* compiled code */ } + def foo914(): scala.Int = { /* compiled code */ } + def foo915(): scala.Int = { /* compiled code */ } + def foo916(): scala.Int = { /* compiled code */ } + def foo917(): scala.Int = { /* compiled code */ } + def foo918(): scala.Int = { /* compiled code */ } + def foo919(): scala.Int = { /* compiled code */ } + def foo920(): scala.Int = { /* compiled code */ } + def foo921(): scala.Int = { /* compiled code */ } + def foo922(): scala.Int = { /* compiled code */ } + def foo923(): scala.Int = { /* compiled code */ } + def foo924(): scala.Int = { /* compiled code */ } + def foo925(): scala.Int = { /* compiled code */ } + def foo926(): scala.Int = { /* compiled code */ } + def foo927(): scala.Int = { /* compiled code */ } + def foo928(): scala.Int = { /* compiled code */ } + def foo929(): scala.Int = { /* compiled code */ } + def foo930(): scala.Int = { /* compiled code */ } + def foo931(): scala.Int = { /* compiled code */ } + def foo932(): scala.Int = { /* compiled code */ } + def foo933(): scala.Int = { /* compiled code */ } + def foo934(): scala.Int = { /* compiled code */ } + def foo935(): scala.Int = { /* compiled code */ } + def foo936(): scala.Int = { /* compiled code */ } + def foo937(): scala.Int = { /* compiled code */ } + def foo938(): scala.Int = { /* compiled code */ } + def foo939(): scala.Int = { /* compiled code */ } + def foo940(): scala.Int = { /* compiled code */ } + def foo941(): scala.Int = { /* compiled code */ } + def foo942(): scala.Int = { /* compiled code */ } + def foo943(): scala.Int = { /* compiled code */ } + def foo944(): scala.Int = { /* compiled code */ } + def foo945(): scala.Int = { /* compiled code */ } + def foo946(): scala.Int = { /* compiled code */ } + def foo947(): scala.Int = { /* compiled code */ } + def foo948(): scala.Int = { /* compiled code */ } + def foo949(): scala.Int = { /* compiled code */ } + def foo950(): scala.Int = { /* compiled code */ } + def foo951(): scala.Int = { /* compiled code */ } + def foo952(): scala.Int = { /* compiled code */ } + def foo953(): scala.Int = { /* compiled code */ } + def foo954(): scala.Int = { /* compiled code */ } + def foo955(): scala.Int = { /* compiled code */ } + def foo956(): scala.Int = { /* compiled code */ } + def foo957(): scala.Int = { /* compiled code */ } + def foo958(): scala.Int = { /* compiled code */ } + def foo959(): scala.Int = { /* compiled code */ } + def foo960(): scala.Int = { /* compiled code */ } + def foo961(): scala.Int = { /* compiled code */ } + def foo962(): scala.Int = { /* compiled code */ } + def foo963(): scala.Int = { /* compiled code */ } + def foo964(): scala.Int = { /* compiled code */ } + def foo965(): scala.Int = { /* compiled code */ } + def foo966(): scala.Int = { /* compiled code */ } + def foo967(): scala.Int = { /* compiled code */ } + def foo968(): scala.Int = { /* compiled code */ } + def foo969(): scala.Int = { /* compiled code */ } + def foo970(): scala.Int = { /* compiled code */ } + def foo971(): scala.Int = { /* compiled code */ } + def foo972(): scala.Int = { /* compiled code */ } + def foo973(): scala.Int = { /* compiled code */ } + def foo974(): scala.Int = { /* compiled code */ } + def foo975(): scala.Int = { /* compiled code */ } + def foo976(): scala.Int = { /* compiled code */ } + def foo977(): scala.Int = { /* compiled code */ } + def foo978(): scala.Int = { /* compiled code */ } + def foo979(): scala.Int = { /* compiled code */ } + def foo980(): scala.Int = { /* compiled code */ } + def foo981(): scala.Int = { /* compiled code */ } + def foo982(): scala.Int = { /* compiled code */ } + def foo983(): scala.Int = { /* compiled code */ } + def foo984(): scala.Int = { /* compiled code */ } + def foo985(): scala.Int = { /* compiled code */ } + def foo986(): scala.Int = { /* compiled code */ } + def foo987(): scala.Int = { /* compiled code */ } + def foo988(): scala.Int = { /* compiled code */ } + def foo989(): scala.Int = { /* compiled code */ } + def foo990(): scala.Int = { /* compiled code */ } + def foo991(): scala.Int = { /* compiled code */ } + def foo992(): scala.Int = { /* compiled code */ } + def foo993(): scala.Int = { /* compiled code */ } + def foo994(): scala.Int = { /* compiled code */ } + def foo995(): scala.Int = { /* compiled code */ } + def foo996(): scala.Int = { /* compiled code */ } + def foo997(): scala.Int = { /* compiled code */ } + def foo998(): scala.Int = { /* compiled code */ } + def foo999(): scala.Int = { /* compiled code */ } + def foo1000(): scala.Int = { /* compiled code */ } + def foo1001(): scala.Int = { /* compiled code */ } + def foo1002(): scala.Int = { /* compiled code */ } + def foo1003(): scala.Int = { /* compiled code */ } + def foo1004(): scala.Int = { /* compiled code */ } + def foo1005(): scala.Int = { /* compiled code */ } + def foo1006(): scala.Int = { /* compiled code */ } + def foo1007(): scala.Int = { /* compiled code */ } + def foo1008(): scala.Int = { /* compiled code */ } + def foo1009(): scala.Int = { /* compiled code */ } + def foo1010(): scala.Int = { /* compiled code */ } + def foo1011(): scala.Int = { /* compiled code */ } + def foo1012(): scala.Int = { /* compiled code */ } + def foo1013(): scala.Int = { /* compiled code */ } + def foo1014(): scala.Int = { /* compiled code */ } + def foo1015(): scala.Int = { /* compiled code */ } + def foo1016(): scala.Int = { /* compiled code */ } + def foo1017(): scala.Int = { /* compiled code */ } + def foo1018(): scala.Int = { /* compiled code */ } + def foo1019(): scala.Int = { /* compiled code */ } + def foo1020(): scala.Int = { /* compiled code */ } + def foo1021(): scala.Int = { /* compiled code */ } + def foo1022(): scala.Int = { /* compiled code */ } + def foo1023(): scala.Int = { /* compiled code */ } + def foo1024(): scala.Int = { /* compiled code */ } + def foo1025(): scala.Int = { /* compiled code */ } + def foo1026(): scala.Int = { /* compiled code */ } + def foo1027(): scala.Int = { /* compiled code */ } + def foo1028(): scala.Int = { /* compiled code */ } + def foo1029(): scala.Int = { /* compiled code */ } + def foo1030(): scala.Int = { /* compiled code */ } + def foo1031(): scala.Int = { /* compiled code */ } + def foo1032(): scala.Int = { /* compiled code */ } + def foo1033(): scala.Int = { /* compiled code */ } + def foo1034(): scala.Int = { /* compiled code */ } + def foo1035(): scala.Int = { /* compiled code */ } + def foo1036(): scala.Int = { /* compiled code */ } + def foo1037(): scala.Int = { /* compiled code */ } + def foo1038(): scala.Int = { /* compiled code */ } + def foo1039(): scala.Int = { /* compiled code */ } + def foo1040(): scala.Int = { /* compiled code */ } + def foo1041(): scala.Int = { /* compiled code */ } + def foo1042(): scala.Int = { /* compiled code */ } + def foo1043(): scala.Int = { /* compiled code */ } + def foo1044(): scala.Int = { /* compiled code */ } + def foo1045(): scala.Int = { /* compiled code */ } + def foo1046(): scala.Int = { /* compiled code */ } + def foo1047(): scala.Int = { /* compiled code */ } + def foo1048(): scala.Int = { /* compiled code */ } + def foo1049(): scala.Int = { /* compiled code */ } + def foo1050(): scala.Int = { /* compiled code */ } + def foo1051(): scala.Int = { /* compiled code */ } + def foo1052(): scala.Int = { /* compiled code */ } + def foo1053(): scala.Int = { /* compiled code */ } + def foo1054(): scala.Int = { /* compiled code */ } + def foo1055(): scala.Int = { /* compiled code */ } + def foo1056(): scala.Int = { /* compiled code */ } + def foo1057(): scala.Int = { /* compiled code */ } + def foo1058(): scala.Int = { /* compiled code */ } + def foo1059(): scala.Int = { /* compiled code */ } + def foo1060(): scala.Int = { /* compiled code */ } + def foo1061(): scala.Int = { /* compiled code */ } + def foo1062(): scala.Int = { /* compiled code */ } + def foo1063(): scala.Int = { /* compiled code */ } + def foo1064(): scala.Int = { /* compiled code */ } + def foo1065(): scala.Int = { /* compiled code */ } + def foo1066(): scala.Int = { /* compiled code */ } + def foo1067(): scala.Int = { /* compiled code */ } + def foo1068(): scala.Int = { /* compiled code */ } + def foo1069(): scala.Int = { /* compiled code */ } + def foo1070(): scala.Int = { /* compiled code */ } + def foo1071(): scala.Int = { /* compiled code */ } + def foo1072(): scala.Int = { /* compiled code */ } + def foo1073(): scala.Int = { /* compiled code */ } + def foo1074(): scala.Int = { /* compiled code */ } + def foo1075(): scala.Int = { /* compiled code */ } + def foo1076(): scala.Int = { /* compiled code */ } + def foo1077(): scala.Int = { /* compiled code */ } + def foo1078(): scala.Int = { /* compiled code */ } + def foo1079(): scala.Int = { /* compiled code */ } + def foo1080(): scala.Int = { /* compiled code */ } + def foo1081(): scala.Int = { /* compiled code */ } + def foo1082(): scala.Int = { /* compiled code */ } + def foo1083(): scala.Int = { /* compiled code */ } + def foo1084(): scala.Int = { /* compiled code */ } + def foo1085(): scala.Int = { /* compiled code */ } + def foo1086(): scala.Int = { /* compiled code */ } + def foo1087(): scala.Int = { /* compiled code */ } + def foo1088(): scala.Int = { /* compiled code */ } + def foo1089(): scala.Int = { /* compiled code */ } + def foo1090(): scala.Int = { /* compiled code */ } + def foo1091(): scala.Int = { /* compiled code */ } + def foo1092(): scala.Int = { /* compiled code */ } + def foo1093(): scala.Int = { /* compiled code */ } + def foo1094(): scala.Int = { /* compiled code */ } + def foo1095(): scala.Int = { /* compiled code */ } + def foo1096(): scala.Int = { /* compiled code */ } + def foo1097(): scala.Int = { /* compiled code */ } + def foo1098(): scala.Int = { /* compiled code */ } + def foo1099(): scala.Int = { /* compiled code */ } + def foo1100(): scala.Int = { /* compiled code */ } + def foo1101(): scala.Int = { /* compiled code */ } + def foo1102(): scala.Int = { /* compiled code */ } + def foo1103(): scala.Int = { /* compiled code */ } + def foo1104(): scala.Int = { /* compiled code */ } + def foo1105(): scala.Int = { /* compiled code */ } + def foo1106(): scala.Int = { /* compiled code */ } + def foo1107(): scala.Int = { /* compiled code */ } + def foo1108(): scala.Int = { /* compiled code */ } + def foo1109(): scala.Int = { /* compiled code */ } + def foo1110(): scala.Int = { /* compiled code */ } + def foo1111(): scala.Int = { /* compiled code */ } + def foo1112(): scala.Int = { /* compiled code */ } + def foo1113(): scala.Int = { /* compiled code */ } + def foo1114(): scala.Int = { /* compiled code */ } + def foo1115(): scala.Int = { /* compiled code */ } + def foo1116(): scala.Int = { /* compiled code */ } + def foo1117(): scala.Int = { /* compiled code */ } + def foo1118(): scala.Int = { /* compiled code */ } + def foo1119(): scala.Int = { /* compiled code */ } + def foo1120(): scala.Int = { /* compiled code */ } + def foo1121(): scala.Int = { /* compiled code */ } + def foo1122(): scala.Int = { /* compiled code */ } + def foo1123(): scala.Int = { /* compiled code */ } + def foo1124(): scala.Int = { /* compiled code */ } + def foo1125(): scala.Int = { /* compiled code */ } + def foo1126(): scala.Int = { /* compiled code */ } + def foo1127(): scala.Int = { /* compiled code */ } + def foo1128(): scala.Int = { /* compiled code */ } + def foo1129(): scala.Int = { /* compiled code */ } + def foo1130(): scala.Int = { /* compiled code */ } + def foo1131(): scala.Int = { /* compiled code */ } + def foo1132(): scala.Int = { /* compiled code */ } + def foo1133(): scala.Int = { /* compiled code */ } + def foo1134(): scala.Int = { /* compiled code */ } + def foo1135(): scala.Int = { /* compiled code */ } + def foo1136(): scala.Int = { /* compiled code */ } + def foo1137(): scala.Int = { /* compiled code */ } + def foo1138(): scala.Int = { /* compiled code */ } + def foo1139(): scala.Int = { /* compiled code */ } + def foo1140(): scala.Int = { /* compiled code */ } + def foo1141(): scala.Int = { /* compiled code */ } + def foo1142(): scala.Int = { /* compiled code */ } + def foo1143(): scala.Int = { /* compiled code */ } + def foo1144(): scala.Int = { /* compiled code */ } + def foo1145(): scala.Int = { /* compiled code */ } + def foo1146(): scala.Int = { /* compiled code */ } + def foo1147(): scala.Int = { /* compiled code */ } + def foo1148(): scala.Int = { /* compiled code */ } + def foo1149(): scala.Int = { /* compiled code */ } + def foo1150(): scala.Int = { /* compiled code */ } + def foo1151(): scala.Int = { /* compiled code */ } + def foo1152(): scala.Int = { /* compiled code */ } + def foo1153(): scala.Int = { /* compiled code */ } + def foo1154(): scala.Int = { /* compiled code */ } + def foo1155(): scala.Int = { /* compiled code */ } + def foo1156(): scala.Int = { /* compiled code */ } + def foo1157(): scala.Int = { /* compiled code */ } + def foo1158(): scala.Int = { /* compiled code */ } + def foo1159(): scala.Int = { /* compiled code */ } + def foo1160(): scala.Int = { /* compiled code */ } + def foo1161(): scala.Int = { /* compiled code */ } + def foo1162(): scala.Int = { /* compiled code */ } + def foo1163(): scala.Int = { /* compiled code */ } + def foo1164(): scala.Int = { /* compiled code */ } + def foo1165(): scala.Int = { /* compiled code */ } + def foo1166(): scala.Int = { /* compiled code */ } + def foo1167(): scala.Int = { /* compiled code */ } + def foo1168(): scala.Int = { /* compiled code */ } + def foo1169(): scala.Int = { /* compiled code */ } + def foo1170(): scala.Int = { /* compiled code */ } + def foo1171(): scala.Int = { /* compiled code */ } + def foo1172(): scala.Int = { /* compiled code */ } + def foo1173(): scala.Int = { /* compiled code */ } + def foo1174(): scala.Int = { /* compiled code */ } + def foo1175(): scala.Int = { /* compiled code */ } + def foo1176(): scala.Int = { /* compiled code */ } + def foo1177(): scala.Int = { /* compiled code */ } + def foo1178(): scala.Int = { /* compiled code */ } + def foo1179(): scala.Int = { /* compiled code */ } + def foo1180(): scala.Int = { /* compiled code */ } + def foo1181(): scala.Int = { /* compiled code */ } + def foo1182(): scala.Int = { /* compiled code */ } + def foo1183(): scala.Int = { /* compiled code */ } + def foo1184(): scala.Int = { /* compiled code */ } + def foo1185(): scala.Int = { /* compiled code */ } + def foo1186(): scala.Int = { /* compiled code */ } + def foo1187(): scala.Int = { /* compiled code */ } + def foo1188(): scala.Int = { /* compiled code */ } + def foo1189(): scala.Int = { /* compiled code */ } + def foo1190(): scala.Int = { /* compiled code */ } + def foo1191(): scala.Int = { /* compiled code */ } + def foo1192(): scala.Int = { /* compiled code */ } + def foo1193(): scala.Int = { /* compiled code */ } + def foo1194(): scala.Int = { /* compiled code */ } + def foo1195(): scala.Int = { /* compiled code */ } + def foo1196(): scala.Int = { /* compiled code */ } + def foo1197(): scala.Int = { /* compiled code */ } + def foo1198(): scala.Int = { /* compiled code */ } + def foo1199(): scala.Int = { /* compiled code */ } + def foo1200(): scala.Int = { /* compiled code */ } + def foo1201(): scala.Int = { /* compiled code */ } + def foo1202(): scala.Int = { /* compiled code */ } + def foo1203(): scala.Int = { /* compiled code */ } + def foo1204(): scala.Int = { /* compiled code */ } + def foo1205(): scala.Int = { /* compiled code */ } + def foo1206(): scala.Int = { /* compiled code */ } + def foo1207(): scala.Int = { /* compiled code */ } + def foo1208(): scala.Int = { /* compiled code */ } + def foo1209(): scala.Int = { /* compiled code */ } + def foo1210(): scala.Int = { /* compiled code */ } + def foo1211(): scala.Int = { /* compiled code */ } + def foo1212(): scala.Int = { /* compiled code */ } + def foo1213(): scala.Int = { /* compiled code */ } + def foo1214(): scala.Int = { /* compiled code */ } + def foo1215(): scala.Int = { /* compiled code */ } + def foo1216(): scala.Int = { /* compiled code */ } + def foo1217(): scala.Int = { /* compiled code */ } + def foo1218(): scala.Int = { /* compiled code */ } + def foo1219(): scala.Int = { /* compiled code */ } + def foo1220(): scala.Int = { /* compiled code */ } + def foo1221(): scala.Int = { /* compiled code */ } + def foo1222(): scala.Int = { /* compiled code */ } + def foo1223(): scala.Int = { /* compiled code */ } + def foo1224(): scala.Int = { /* compiled code */ } + def foo1225(): scala.Int = { /* compiled code */ } + def foo1226(): scala.Int = { /* compiled code */ } + def foo1227(): scala.Int = { /* compiled code */ } + def foo1228(): scala.Int = { /* compiled code */ } + def foo1229(): scala.Int = { /* compiled code */ } + def foo1230(): scala.Int = { /* compiled code */ } + def foo1231(): scala.Int = { /* compiled code */ } + def foo1232(): scala.Int = { /* compiled code */ } + def foo1233(): scala.Int = { /* compiled code */ } + def foo1234(): scala.Int = { /* compiled code */ } + def foo1235(): scala.Int = { /* compiled code */ } + def foo1236(): scala.Int = { /* compiled code */ } + def foo1237(): scala.Int = { /* compiled code */ } + def foo1238(): scala.Int = { /* compiled code */ } + def foo1239(): scala.Int = { /* compiled code */ } + def foo1240(): scala.Int = { /* compiled code */ } + def foo1241(): scala.Int = { /* compiled code */ } + def foo1242(): scala.Int = { /* compiled code */ } + def foo1243(): scala.Int = { /* compiled code */ } + def foo1244(): scala.Int = { /* compiled code */ } + def foo1245(): scala.Int = { /* compiled code */ } + def foo1246(): scala.Int = { /* compiled code */ } + def foo1247(): scala.Int = { /* compiled code */ } + def foo1248(): scala.Int = { /* compiled code */ } + def foo1249(): scala.Int = { /* compiled code */ } + def foo1250(): scala.Int = { /* compiled code */ } + def foo1251(): scala.Int = { /* compiled code */ } + def foo1252(): scala.Int = { /* compiled code */ } + def foo1253(): scala.Int = { /* compiled code */ } + def foo1254(): scala.Int = { /* compiled code */ } + def foo1255(): scala.Int = { /* compiled code */ } + def foo1256(): scala.Int = { /* compiled code */ } + def foo1257(): scala.Int = { /* compiled code */ } + def foo1258(): scala.Int = { /* compiled code */ } + def foo1259(): scala.Int = { /* compiled code */ } + def foo1260(): scala.Int = { /* compiled code */ } + def foo1261(): scala.Int = { /* compiled code */ } + def foo1262(): scala.Int = { /* compiled code */ } + def foo1263(): scala.Int = { /* compiled code */ } + def foo1264(): scala.Int = { /* compiled code */ } + def foo1265(): scala.Int = { /* compiled code */ } + def foo1266(): scala.Int = { /* compiled code */ } + def foo1267(): scala.Int = { /* compiled code */ } + def foo1268(): scala.Int = { /* compiled code */ } + def foo1269(): scala.Int = { /* compiled code */ } + def foo1270(): scala.Int = { /* compiled code */ } + def foo1271(): scala.Int = { /* compiled code */ } + def foo1272(): scala.Int = { /* compiled code */ } + def foo1273(): scala.Int = { /* compiled code */ } + def foo1274(): scala.Int = { /* compiled code */ } + def foo1275(): scala.Int = { /* compiled code */ } + def foo1276(): scala.Int = { /* compiled code */ } + def foo1277(): scala.Int = { /* compiled code */ } + def foo1278(): scala.Int = { /* compiled code */ } + def foo1279(): scala.Int = { /* compiled code */ } + def foo1280(): scala.Int = { /* compiled code */ } + def foo1281(): scala.Int = { /* compiled code */ } + def foo1282(): scala.Int = { /* compiled code */ } + def foo1283(): scala.Int = { /* compiled code */ } + def foo1284(): scala.Int = { /* compiled code */ } + def foo1285(): scala.Int = { /* compiled code */ } + def foo1286(): scala.Int = { /* compiled code */ } + def foo1287(): scala.Int = { /* compiled code */ } + def foo1288(): scala.Int = { /* compiled code */ } + def foo1289(): scala.Int = { /* compiled code */ } + def foo1290(): scala.Int = { /* compiled code */ } + def foo1291(): scala.Int = { /* compiled code */ } + def foo1292(): scala.Int = { /* compiled code */ } + def foo1293(): scala.Int = { /* compiled code */ } + def foo1294(): scala.Int = { /* compiled code */ } + def foo1295(): scala.Int = { /* compiled code */ } + def foo1296(): scala.Int = { /* compiled code */ } + def foo1297(): scala.Int = { /* compiled code */ } + def foo1298(): scala.Int = { /* compiled code */ } + def foo1299(): scala.Int = { /* compiled code */ } + def foo1300(): scala.Int = { /* compiled code */ } + def foo1301(): scala.Int = { /* compiled code */ } + def foo1302(): scala.Int = { /* compiled code */ } + def foo1303(): scala.Int = { /* compiled code */ } + def foo1304(): scala.Int = { /* compiled code */ } + def foo1305(): scala.Int = { /* compiled code */ } + def foo1306(): scala.Int = { /* compiled code */ } + def foo1307(): scala.Int = { /* compiled code */ } + def foo1308(): scala.Int = { /* compiled code */ } + def foo1309(): scala.Int = { /* compiled code */ } + def foo1310(): scala.Int = { /* compiled code */ } + def foo1311(): scala.Int = { /* compiled code */ } + def foo1312(): scala.Int = { /* compiled code */ } + def foo1313(): scala.Int = { /* compiled code */ } + def foo1314(): scala.Int = { /* compiled code */ } + def foo1315(): scala.Int = { /* compiled code */ } + def foo1316(): scala.Int = { /* compiled code */ } + def foo1317(): scala.Int = { /* compiled code */ } + def foo1318(): scala.Int = { /* compiled code */ } + def foo1319(): scala.Int = { /* compiled code */ } + def foo1320(): scala.Int = { /* compiled code */ } + def foo1321(): scala.Int = { /* compiled code */ } + def foo1322(): scala.Int = { /* compiled code */ } + def foo1323(): scala.Int = { /* compiled code */ } + def foo1324(): scala.Int = { /* compiled code */ } + def foo1325(): scala.Int = { /* compiled code */ } + def foo1326(): scala.Int = { /* compiled code */ } + def foo1327(): scala.Int = { /* compiled code */ } + def foo1328(): scala.Int = { /* compiled code */ } + def foo1329(): scala.Int = { /* compiled code */ } + def foo1330(): scala.Int = { /* compiled code */ } + def foo1331(): scala.Int = { /* compiled code */ } + def foo1332(): scala.Int = { /* compiled code */ } + def foo1333(): scala.Int = { /* compiled code */ } + def foo1334(): scala.Int = { /* compiled code */ } + def foo1335(): scala.Int = { /* compiled code */ } + def foo1336(): scala.Int = { /* compiled code */ } + def foo1337(): scala.Int = { /* compiled code */ } + def foo1338(): scala.Int = { /* compiled code */ } + def foo1339(): scala.Int = { /* compiled code */ } + def foo1340(): scala.Int = { /* compiled code */ } + def foo1341(): scala.Int = { /* compiled code */ } + def foo1342(): scala.Int = { /* compiled code */ } + def foo1343(): scala.Int = { /* compiled code */ } + def foo1344(): scala.Int = { /* compiled code */ } + def foo1345(): scala.Int = { /* compiled code */ } + def foo1346(): scala.Int = { /* compiled code */ } + def foo1347(): scala.Int = { /* compiled code */ } + def foo1348(): scala.Int = { /* compiled code */ } + def foo1349(): scala.Int = { /* compiled code */ } + def foo1350(): scala.Int = { /* compiled code */ } + def foo1351(): scala.Int = { /* compiled code */ } + def foo1352(): scala.Int = { /* compiled code */ } + def foo1353(): scala.Int = { /* compiled code */ } + def foo1354(): scala.Int = { /* compiled code */ } + def foo1355(): scala.Int = { /* compiled code */ } + def foo1356(): scala.Int = { /* compiled code */ } + def foo1357(): scala.Int = { /* compiled code */ } + def foo1358(): scala.Int = { /* compiled code */ } + def foo1359(): scala.Int = { /* compiled code */ } + def foo1360(): scala.Int = { /* compiled code */ } + def foo1361(): scala.Int = { /* compiled code */ } + def foo1362(): scala.Int = { /* compiled code */ } + def foo1363(): scala.Int = { /* compiled code */ } + def foo1364(): scala.Int = { /* compiled code */ } + def foo1365(): scala.Int = { /* compiled code */ } + def foo1366(): scala.Int = { /* compiled code */ } + def foo1367(): scala.Int = { /* compiled code */ } + def foo1368(): scala.Int = { /* compiled code */ } + def foo1369(): scala.Int = { /* compiled code */ } + def foo1370(): scala.Int = { /* compiled code */ } + def foo1371(): scala.Int = { /* compiled code */ } + def foo1372(): scala.Int = { /* compiled code */ } + def foo1373(): scala.Int = { /* compiled code */ } + def foo1374(): scala.Int = { /* compiled code */ } + def foo1375(): scala.Int = { /* compiled code */ } + def foo1376(): scala.Int = { /* compiled code */ } + def foo1377(): scala.Int = { /* compiled code */ } + def foo1378(): scala.Int = { /* compiled code */ } + def foo1379(): scala.Int = { /* compiled code */ } + def foo1380(): scala.Int = { /* compiled code */ } + def foo1381(): scala.Int = { /* compiled code */ } + def foo1382(): scala.Int = { /* compiled code */ } + def foo1383(): scala.Int = { /* compiled code */ } + def foo1384(): scala.Int = { /* compiled code */ } + def foo1385(): scala.Int = { /* compiled code */ } + def foo1386(): scala.Int = { /* compiled code */ } + def foo1387(): scala.Int = { /* compiled code */ } + def foo1388(): scala.Int = { /* compiled code */ } + def foo1389(): scala.Int = { /* compiled code */ } + def foo1390(): scala.Int = { /* compiled code */ } + def foo1391(): scala.Int = { /* compiled code */ } + def foo1392(): scala.Int = { /* compiled code */ } + def foo1393(): scala.Int = { /* compiled code */ } + def foo1394(): scala.Int = { /* compiled code */ } + def foo1395(): scala.Int = { /* compiled code */ } + def foo1396(): scala.Int = { /* compiled code */ } + def foo1397(): scala.Int = { /* compiled code */ } + def foo1398(): scala.Int = { /* compiled code */ } + def foo1399(): scala.Int = { /* compiled code */ } + def foo1400(): scala.Int = { /* compiled code */ } + def foo1401(): scala.Int = { /* compiled code */ } + def foo1402(): scala.Int = { /* compiled code */ } + def foo1403(): scala.Int = { /* compiled code */ } + def foo1404(): scala.Int = { /* compiled code */ } + def foo1405(): scala.Int = { /* compiled code */ } + def foo1406(): scala.Int = { /* compiled code */ } + def foo1407(): scala.Int = { /* compiled code */ } + def foo1408(): scala.Int = { /* compiled code */ } + def foo1409(): scala.Int = { /* compiled code */ } + def foo1410(): scala.Int = { /* compiled code */ } + def foo1411(): scala.Int = { /* compiled code */ } + def foo1412(): scala.Int = { /* compiled code */ } + def foo1413(): scala.Int = { /* compiled code */ } + def foo1414(): scala.Int = { /* compiled code */ } + def foo1415(): scala.Int = { /* compiled code */ } + def foo1416(): scala.Int = { /* compiled code */ } + def foo1417(): scala.Int = { /* compiled code */ } + def foo1418(): scala.Int = { /* compiled code */ } + def foo1419(): scala.Int = { /* compiled code */ } + def foo1420(): scala.Int = { /* compiled code */ } + def foo1421(): scala.Int = { /* compiled code */ } + def foo1422(): scala.Int = { /* compiled code */ } + def foo1423(): scala.Int = { /* compiled code */ } + def foo1424(): scala.Int = { /* compiled code */ } + def foo1425(): scala.Int = { /* compiled code */ } + def foo1426(): scala.Int = { /* compiled code */ } + def foo1427(): scala.Int = { /* compiled code */ } + def foo1428(): scala.Int = { /* compiled code */ } + def foo1429(): scala.Int = { /* compiled code */ } + def foo1430(): scala.Int = { /* compiled code */ } + def foo1431(): scala.Int = { /* compiled code */ } + def foo1432(): scala.Int = { /* compiled code */ } + def foo1433(): scala.Int = { /* compiled code */ } + def foo1434(): scala.Int = { /* compiled code */ } + def foo1435(): scala.Int = { /* compiled code */ } + def foo1436(): scala.Int = { /* compiled code */ } + def foo1437(): scala.Int = { /* compiled code */ } + def foo1438(): scala.Int = { /* compiled code */ } + def foo1439(): scala.Int = { /* compiled code */ } + def foo1440(): scala.Int = { /* compiled code */ } + def foo1441(): scala.Int = { /* compiled code */ } + def foo1442(): scala.Int = { /* compiled code */ } + def foo1443(): scala.Int = { /* compiled code */ } + def foo1444(): scala.Int = { /* compiled code */ } + def foo1445(): scala.Int = { /* compiled code */ } + def foo1446(): scala.Int = { /* compiled code */ } + def foo1447(): scala.Int = { /* compiled code */ } + def foo1448(): scala.Int = { /* compiled code */ } + def foo1449(): scala.Int = { /* compiled code */ } + def foo1450(): scala.Int = { /* compiled code */ } + def foo1451(): scala.Int = { /* compiled code */ } + def foo1452(): scala.Int = { /* compiled code */ } + def foo1453(): scala.Int = { /* compiled code */ } + def foo1454(): scala.Int = { /* compiled code */ } + def foo1455(): scala.Int = { /* compiled code */ } + def foo1456(): scala.Int = { /* compiled code */ } + def foo1457(): scala.Int = { /* compiled code */ } + def foo1458(): scala.Int = { /* compiled code */ } + def foo1459(): scala.Int = { /* compiled code */ } + def foo1460(): scala.Int = { /* compiled code */ } + def foo1461(): scala.Int = { /* compiled code */ } + def foo1462(): scala.Int = { /* compiled code */ } + def foo1463(): scala.Int = { /* compiled code */ } + def foo1464(): scala.Int = { /* compiled code */ } + def foo1465(): scala.Int = { /* compiled code */ } + def foo1466(): scala.Int = { /* compiled code */ } + def foo1467(): scala.Int = { /* compiled code */ } + def foo1468(): scala.Int = { /* compiled code */ } + def foo1469(): scala.Int = { /* compiled code */ } + def foo1470(): scala.Int = { /* compiled code */ } + def foo1471(): scala.Int = { /* compiled code */ } + def foo1472(): scala.Int = { /* compiled code */ } + def foo1473(): scala.Int = { /* compiled code */ } + def foo1474(): scala.Int = { /* compiled code */ } + def foo1475(): scala.Int = { /* compiled code */ } + def foo1476(): scala.Int = { /* compiled code */ } + def foo1477(): scala.Int = { /* compiled code */ } + def foo1478(): scala.Int = { /* compiled code */ } + def foo1479(): scala.Int = { /* compiled code */ } + def foo1480(): scala.Int = { /* compiled code */ } + def foo1481(): scala.Int = { /* compiled code */ } + def foo1482(): scala.Int = { /* compiled code */ } + def foo1483(): scala.Int = { /* compiled code */ } + def foo1484(): scala.Int = { /* compiled code */ } + def foo1485(): scala.Int = { /* compiled code */ } + def foo1486(): scala.Int = { /* compiled code */ } + def foo1487(): scala.Int = { /* compiled code */ } + def foo1488(): scala.Int = { /* compiled code */ } + def foo1489(): scala.Int = { /* compiled code */ } + def foo1490(): scala.Int = { /* compiled code */ } + def foo1491(): scala.Int = { /* compiled code */ } + def foo1492(): scala.Int = { /* compiled code */ } + def foo1493(): scala.Int = { /* compiled code */ } + def foo1494(): scala.Int = { /* compiled code */ } + def foo1495(): scala.Int = { /* compiled code */ } + def foo1496(): scala.Int = { /* compiled code */ } + def foo1497(): scala.Int = { /* compiled code */ } + def foo1498(): scala.Int = { /* compiled code */ } + def foo1499(): scala.Int = { /* compiled code */ } + def foo1500(): scala.Int = { /* compiled code */ } + def foo1501(): scala.Int = { /* compiled code */ } + def foo1502(): scala.Int = { /* compiled code */ } + def foo1503(): scala.Int = { /* compiled code */ } + def foo1504(): scala.Int = { /* compiled code */ } + def foo1505(): scala.Int = { /* compiled code */ } + def foo1506(): scala.Int = { /* compiled code */ } + def foo1507(): scala.Int = { /* compiled code */ } + def foo1508(): scala.Int = { /* compiled code */ } + def foo1509(): scala.Int = { /* compiled code */ } + def foo1510(): scala.Int = { /* compiled code */ } + def foo1511(): scala.Int = { /* compiled code */ } + def foo1512(): scala.Int = { /* compiled code */ } + def foo1513(): scala.Int = { /* compiled code */ } + def foo1514(): scala.Int = { /* compiled code */ } + def foo1515(): scala.Int = { /* compiled code */ } + def foo1516(): scala.Int = { /* compiled code */ } + def foo1517(): scala.Int = { /* compiled code */ } + def foo1518(): scala.Int = { /* compiled code */ } + def foo1519(): scala.Int = { /* compiled code */ } + def foo1520(): scala.Int = { /* compiled code */ } + def foo1521(): scala.Int = { /* compiled code */ } + def foo1522(): scala.Int = { /* compiled code */ } + def foo1523(): scala.Int = { /* compiled code */ } + def foo1524(): scala.Int = { /* compiled code */ } + def foo1525(): scala.Int = { /* compiled code */ } + def foo1526(): scala.Int = { /* compiled code */ } + def foo1527(): scala.Int = { /* compiled code */ } + def foo1528(): scala.Int = { /* compiled code */ } + def foo1529(): scala.Int = { /* compiled code */ } + def foo1530(): scala.Int = { /* compiled code */ } + def foo1531(): scala.Int = { /* compiled code */ } + def foo1532(): scala.Int = { /* compiled code */ } + def foo1533(): scala.Int = { /* compiled code */ } + def foo1534(): scala.Int = { /* compiled code */ } + def foo1535(): scala.Int = { /* compiled code */ } + def foo1536(): scala.Int = { /* compiled code */ } + def foo1537(): scala.Int = { /* compiled code */ } + def foo1538(): scala.Int = { /* compiled code */ } + def foo1539(): scala.Int = { /* compiled code */ } + def foo1540(): scala.Int = { /* compiled code */ } + def foo1541(): scala.Int = { /* compiled code */ } + def foo1542(): scala.Int = { /* compiled code */ } + def foo1543(): scala.Int = { /* compiled code */ } + def foo1544(): scala.Int = { /* compiled code */ } + def foo1545(): scala.Int = { /* compiled code */ } + def foo1546(): scala.Int = { /* compiled code */ } + def foo1547(): scala.Int = { /* compiled code */ } + def foo1548(): scala.Int = { /* compiled code */ } + def foo1549(): scala.Int = { /* compiled code */ } + def foo1550(): scala.Int = { /* compiled code */ } + def foo1551(): scala.Int = { /* compiled code */ } + def foo1552(): scala.Int = { /* compiled code */ } + def foo1553(): scala.Int = { /* compiled code */ } + def foo1554(): scala.Int = { /* compiled code */ } + def foo1555(): scala.Int = { /* compiled code */ } + def foo1556(): scala.Int = { /* compiled code */ } + def foo1557(): scala.Int = { /* compiled code */ } + def foo1558(): scala.Int = { /* compiled code */ } + def foo1559(): scala.Int = { /* compiled code */ } + def foo1560(): scala.Int = { /* compiled code */ } + def foo1561(): scala.Int = { /* compiled code */ } + def foo1562(): scala.Int = { /* compiled code */ } + def foo1563(): scala.Int = { /* compiled code */ } + def foo1564(): scala.Int = { /* compiled code */ } + def foo1565(): scala.Int = { /* compiled code */ } + def foo1566(): scala.Int = { /* compiled code */ } + def foo1567(): scala.Int = { /* compiled code */ } + def foo1568(): scala.Int = { /* compiled code */ } + def foo1569(): scala.Int = { /* compiled code */ } + def foo1570(): scala.Int = { /* compiled code */ } + def foo1571(): scala.Int = { /* compiled code */ } + def foo1572(): scala.Int = { /* compiled code */ } + def foo1573(): scala.Int = { /* compiled code */ } + def foo1574(): scala.Int = { /* compiled code */ } + def foo1575(): scala.Int = { /* compiled code */ } + def foo1576(): scala.Int = { /* compiled code */ } + def foo1577(): scala.Int = { /* compiled code */ } + def foo1578(): scala.Int = { /* compiled code */ } + def foo1579(): scala.Int = { /* compiled code */ } + def foo1580(): scala.Int = { /* compiled code */ } + def foo1581(): scala.Int = { /* compiled code */ } + def foo1582(): scala.Int = { /* compiled code */ } + def foo1583(): scala.Int = { /* compiled code */ } + def foo1584(): scala.Int = { /* compiled code */ } + def foo1585(): scala.Int = { /* compiled code */ } + def foo1586(): scala.Int = { /* compiled code */ } + def foo1587(): scala.Int = { /* compiled code */ } + def foo1588(): scala.Int = { /* compiled code */ } + def foo1589(): scala.Int = { /* compiled code */ } + def foo1590(): scala.Int = { /* compiled code */ } + def foo1591(): scala.Int = { /* compiled code */ } + def foo1592(): scala.Int = { /* compiled code */ } + def foo1593(): scala.Int = { /* compiled code */ } + def foo1594(): scala.Int = { /* compiled code */ } + def foo1595(): scala.Int = { /* compiled code */ } + def foo1596(): scala.Int = { /* compiled code */ } + def foo1597(): scala.Int = { /* compiled code */ } + def foo1598(): scala.Int = { /* compiled code */ } + def foo1599(): scala.Int = { /* compiled code */ } + def foo1600(): scala.Int = { /* compiled code */ } + def foo1601(): scala.Int = { /* compiled code */ } + def foo1602(): scala.Int = { /* compiled code */ } + def foo1603(): scala.Int = { /* compiled code */ } + def foo1604(): scala.Int = { /* compiled code */ } + def foo1605(): scala.Int = { /* compiled code */ } + def foo1606(): scala.Int = { /* compiled code */ } + def foo1607(): scala.Int = { /* compiled code */ } + def foo1608(): scala.Int = { /* compiled code */ } + def foo1609(): scala.Int = { /* compiled code */ } + def foo1610(): scala.Int = { /* compiled code */ } + def foo1611(): scala.Int = { /* compiled code */ } + def foo1612(): scala.Int = { /* compiled code */ } + def foo1613(): scala.Int = { /* compiled code */ } + def foo1614(): scala.Int = { /* compiled code */ } + def foo1615(): scala.Int = { /* compiled code */ } + def foo1616(): scala.Int = { /* compiled code */ } + def foo1617(): scala.Int = { /* compiled code */ } + def foo1618(): scala.Int = { /* compiled code */ } + def foo1619(): scala.Int = { /* compiled code */ } + def foo1620(): scala.Int = { /* compiled code */ } + def foo1621(): scala.Int = { /* compiled code */ } + def foo1622(): scala.Int = { /* compiled code */ } + def foo1623(): scala.Int = { /* compiled code */ } + def foo1624(): scala.Int = { /* compiled code */ } + def foo1625(): scala.Int = { /* compiled code */ } + def foo1626(): scala.Int = { /* compiled code */ } + def foo1627(): scala.Int = { /* compiled code */ } + def foo1628(): scala.Int = { /* compiled code */ } + def foo1629(): scala.Int = { /* compiled code */ } + def foo1630(): scala.Int = { /* compiled code */ } + def foo1631(): scala.Int = { /* compiled code */ } + def foo1632(): scala.Int = { /* compiled code */ } + def foo1633(): scala.Int = { /* compiled code */ } + def foo1634(): scala.Int = { /* compiled code */ } + def foo1635(): scala.Int = { /* compiled code */ } + def foo1636(): scala.Int = { /* compiled code */ } + def foo1637(): scala.Int = { /* compiled code */ } + def foo1638(): scala.Int = { /* compiled code */ } + def foo1639(): scala.Int = { /* compiled code */ } + def foo1640(): scala.Int = { /* compiled code */ } + def foo1641(): scala.Int = { /* compiled code */ } + def foo1642(): scala.Int = { /* compiled code */ } + def foo1643(): scala.Int = { /* compiled code */ } + def foo1644(): scala.Int = { /* compiled code */ } + def foo1645(): scala.Int = { /* compiled code */ } + def foo1646(): scala.Int = { /* compiled code */ } + def foo1647(): scala.Int = { /* compiled code */ } + def foo1648(): scala.Int = { /* compiled code */ } + def foo1649(): scala.Int = { /* compiled code */ } + def foo1650(): scala.Int = { /* compiled code */ } + def foo1651(): scala.Int = { /* compiled code */ } + def foo1652(): scala.Int = { /* compiled code */ } + def foo1653(): scala.Int = { /* compiled code */ } + def foo1654(): scala.Int = { /* compiled code */ } + def foo1655(): scala.Int = { /* compiled code */ } + def foo1656(): scala.Int = { /* compiled code */ } + def foo1657(): scala.Int = { /* compiled code */ } + def foo1658(): scala.Int = { /* compiled code */ } + def foo1659(): scala.Int = { /* compiled code */ } + def foo1660(): scala.Int = { /* compiled code */ } + def foo1661(): scala.Int = { /* compiled code */ } + def foo1662(): scala.Int = { /* compiled code */ } + def foo1663(): scala.Int = { /* compiled code */ } + def foo1664(): scala.Int = { /* compiled code */ } + def foo1665(): scala.Int = { /* compiled code */ } + def foo1666(): scala.Int = { /* compiled code */ } + def foo1667(): scala.Int = { /* compiled code */ } + def foo1668(): scala.Int = { /* compiled code */ } + def foo1669(): scala.Int = { /* compiled code */ } + def foo1670(): scala.Int = { /* compiled code */ } + def foo1671(): scala.Int = { /* compiled code */ } + def foo1672(): scala.Int = { /* compiled code */ } + def foo1673(): scala.Int = { /* compiled code */ } + def foo1674(): scala.Int = { /* compiled code */ } + def foo1675(): scala.Int = { /* compiled code */ } + def foo1676(): scala.Int = { /* compiled code */ } + def foo1677(): scala.Int = { /* compiled code */ } + def foo1678(): scala.Int = { /* compiled code */ } + def foo1679(): scala.Int = { /* compiled code */ } + def foo1680(): scala.Int = { /* compiled code */ } + def foo1681(): scala.Int = { /* compiled code */ } + def foo1682(): scala.Int = { /* compiled code */ } + def foo1683(): scala.Int = { /* compiled code */ } + def foo1684(): scala.Int = { /* compiled code */ } + def foo1685(): scala.Int = { /* compiled code */ } + def foo1686(): scala.Int = { /* compiled code */ } + def foo1687(): scala.Int = { /* compiled code */ } + def foo1688(): scala.Int = { /* compiled code */ } + def foo1689(): scala.Int = { /* compiled code */ } + def foo1690(): scala.Int = { /* compiled code */ } + def foo1691(): scala.Int = { /* compiled code */ } + def foo1692(): scala.Int = { /* compiled code */ } + def foo1693(): scala.Int = { /* compiled code */ } + def foo1694(): scala.Int = { /* compiled code */ } + def foo1695(): scala.Int = { /* compiled code */ } + def foo1696(): scala.Int = { /* compiled code */ } + def foo1697(): scala.Int = { /* compiled code */ } + def foo1698(): scala.Int = { /* compiled code */ } + def foo1699(): scala.Int = { /* compiled code */ } + def foo1700(): scala.Int = { /* compiled code */ } + def foo1701(): scala.Int = { /* compiled code */ } + def foo1702(): scala.Int = { /* compiled code */ } + def foo1703(): scala.Int = { /* compiled code */ } + def foo1704(): scala.Int = { /* compiled code */ } + def foo1705(): scala.Int = { /* compiled code */ } + def foo1706(): scala.Int = { /* compiled code */ } + def foo1707(): scala.Int = { /* compiled code */ } + def foo1708(): scala.Int = { /* compiled code */ } + def foo1709(): scala.Int = { /* compiled code */ } + def foo1710(): scala.Int = { /* compiled code */ } + def foo1711(): scala.Int = { /* compiled code */ } + def foo1712(): scala.Int = { /* compiled code */ } + def foo1713(): scala.Int = { /* compiled code */ } + def foo1714(): scala.Int = { /* compiled code */ } + def foo1715(): scala.Int = { /* compiled code */ } + def foo1716(): scala.Int = { /* compiled code */ } + def foo1717(): scala.Int = { /* compiled code */ } + def foo1718(): scala.Int = { /* compiled code */ } + def foo1719(): scala.Int = { /* compiled code */ } + def foo1720(): scala.Int = { /* compiled code */ } + def foo1721(): scala.Int = { /* compiled code */ } + def foo1722(): scala.Int = { /* compiled code */ } + def foo1723(): scala.Int = { /* compiled code */ } + def foo1724(): scala.Int = { /* compiled code */ } + def foo1725(): scala.Int = { /* compiled code */ } + def foo1726(): scala.Int = { /* compiled code */ } + def foo1727(): scala.Int = { /* compiled code */ } + def foo1728(): scala.Int = { /* compiled code */ } + def foo1729(): scala.Int = { /* compiled code */ } + def foo1730(): scala.Int = { /* compiled code */ } + def foo1731(): scala.Int = { /* compiled code */ } + def foo1732(): scala.Int = { /* compiled code */ } + def foo1733(): scala.Int = { /* compiled code */ } + def foo1734(): scala.Int = { /* compiled code */ } + def foo1735(): scala.Int = { /* compiled code */ } + def foo1736(): scala.Int = { /* compiled code */ } + def foo1737(): scala.Int = { /* compiled code */ } + def foo1738(): scala.Int = { /* compiled code */ } + def foo1739(): scala.Int = { /* compiled code */ } + def foo1740(): scala.Int = { /* compiled code */ } + def foo1741(): scala.Int = { /* compiled code */ } + def foo1742(): scala.Int = { /* compiled code */ } + def foo1743(): scala.Int = { /* compiled code */ } + def foo1744(): scala.Int = { /* compiled code */ } + def foo1745(): scala.Int = { /* compiled code */ } + def foo1746(): scala.Int = { /* compiled code */ } + def foo1747(): scala.Int = { /* compiled code */ } + def foo1748(): scala.Int = { /* compiled code */ } + def foo1749(): scala.Int = { /* compiled code */ } + def foo1750(): scala.Int = { /* compiled code */ } + def foo1751(): scala.Int = { /* compiled code */ } + def foo1752(): scala.Int = { /* compiled code */ } + def foo1753(): scala.Int = { /* compiled code */ } + def foo1754(): scala.Int = { /* compiled code */ } + def foo1755(): scala.Int = { /* compiled code */ } + def foo1756(): scala.Int = { /* compiled code */ } + def foo1757(): scala.Int = { /* compiled code */ } + def foo1758(): scala.Int = { /* compiled code */ } + def foo1759(): scala.Int = { /* compiled code */ } + def foo1760(): scala.Int = { /* compiled code */ } + def foo1761(): scala.Int = { /* compiled code */ } + def foo1762(): scala.Int = { /* compiled code */ } + def foo1763(): scala.Int = { /* compiled code */ } + def foo1764(): scala.Int = { /* compiled code */ } + def foo1765(): scala.Int = { /* compiled code */ } + def foo1766(): scala.Int = { /* compiled code */ } + def foo1767(): scala.Int = { /* compiled code */ } + def foo1768(): scala.Int = { /* compiled code */ } + def foo1769(): scala.Int = { /* compiled code */ } + def foo1770(): scala.Int = { /* compiled code */ } + def foo1771(): scala.Int = { /* compiled code */ } + def foo1772(): scala.Int = { /* compiled code */ } + def foo1773(): scala.Int = { /* compiled code */ } + def foo1774(): scala.Int = { /* compiled code */ } + def foo1775(): scala.Int = { /* compiled code */ } + def foo1776(): scala.Int = { /* compiled code */ } + def foo1777(): scala.Int = { /* compiled code */ } + def foo1778(): scala.Int = { /* compiled code */ } + def foo1779(): scala.Int = { /* compiled code */ } + def foo1780(): scala.Int = { /* compiled code */ } + def foo1781(): scala.Int = { /* compiled code */ } + def foo1782(): scala.Int = { /* compiled code */ } + def foo1783(): scala.Int = { /* compiled code */ } + def foo1784(): scala.Int = { /* compiled code */ } + def foo1785(): scala.Int = { /* compiled code */ } + def foo1786(): scala.Int = { /* compiled code */ } + def foo1787(): scala.Int = { /* compiled code */ } + def foo1788(): scala.Int = { /* compiled code */ } + def foo1789(): scala.Int = { /* compiled code */ } + def foo1790(): scala.Int = { /* compiled code */ } + def foo1791(): scala.Int = { /* compiled code */ } + def foo1792(): scala.Int = { /* compiled code */ } + def foo1793(): scala.Int = { /* compiled code */ } + def foo1794(): scala.Int = { /* compiled code */ } + def foo1795(): scala.Int = { /* compiled code */ } + def foo1796(): scala.Int = { /* compiled code */ } + def foo1797(): scala.Int = { /* compiled code */ } + def foo1798(): scala.Int = { /* compiled code */ } + def foo1799(): scala.Int = { /* compiled code */ } + def foo1800(): scala.Int = { /* compiled code */ } + def foo1801(): scala.Int = { /* compiled code */ } + def foo1802(): scala.Int = { /* compiled code */ } + def foo1803(): scala.Int = { /* compiled code */ } + def foo1804(): scala.Int = { /* compiled code */ } + def foo1805(): scala.Int = { /* compiled code */ } + def foo1806(): scala.Int = { /* compiled code */ } + def foo1807(): scala.Int = { /* compiled code */ } + def foo1808(): scala.Int = { /* compiled code */ } + def foo1809(): scala.Int = { /* compiled code */ } + def foo1810(): scala.Int = { /* compiled code */ } + def foo1811(): scala.Int = { /* compiled code */ } + def foo1812(): scala.Int = { /* compiled code */ } + def foo1813(): scala.Int = { /* compiled code */ } + def foo1814(): scala.Int = { /* compiled code */ } + def foo1815(): scala.Int = { /* compiled code */ } + def foo1816(): scala.Int = { /* compiled code */ } + def foo1817(): scala.Int = { /* compiled code */ } + def foo1818(): scala.Int = { /* compiled code */ } + def foo1819(): scala.Int = { /* compiled code */ } + def foo1820(): scala.Int = { /* compiled code */ } + def foo1821(): scala.Int = { /* compiled code */ } + def foo1822(): scala.Int = { /* compiled code */ } + def foo1823(): scala.Int = { /* compiled code */ } + def foo1824(): scala.Int = { /* compiled code */ } + def foo1825(): scala.Int = { /* compiled code */ } + def foo1826(): scala.Int = { /* compiled code */ } + def foo1827(): scala.Int = { /* compiled code */ } + def foo1828(): scala.Int = { /* compiled code */ } + def foo1829(): scala.Int = { /* compiled code */ } + def foo1830(): scala.Int = { /* compiled code */ } + def foo1831(): scala.Int = { /* compiled code */ } + def foo1832(): scala.Int = { /* compiled code */ } + def foo1833(): scala.Int = { /* compiled code */ } + def foo1834(): scala.Int = { /* compiled code */ } + def foo1835(): scala.Int = { /* compiled code */ } + def foo1836(): scala.Int = { /* compiled code */ } + def foo1837(): scala.Int = { /* compiled code */ } + def foo1838(): scala.Int = { /* compiled code */ } + def foo1839(): scala.Int = { /* compiled code */ } + def foo1840(): scala.Int = { /* compiled code */ } + def foo1841(): scala.Int = { /* compiled code */ } + def foo1842(): scala.Int = { /* compiled code */ } + def foo1843(): scala.Int = { /* compiled code */ } + def foo1844(): scala.Int = { /* compiled code */ } + def foo1845(): scala.Int = { /* compiled code */ } + def foo1846(): scala.Int = { /* compiled code */ } + def foo1847(): scala.Int = { /* compiled code */ } + def foo1848(): scala.Int = { /* compiled code */ } + def foo1849(): scala.Int = { /* compiled code */ } + def foo1850(): scala.Int = { /* compiled code */ } + def foo1851(): scala.Int = { /* compiled code */ } + def foo1852(): scala.Int = { /* compiled code */ } + def foo1853(): scala.Int = { /* compiled code */ } + def foo1854(): scala.Int = { /* compiled code */ } + def foo1855(): scala.Int = { /* compiled code */ } + def foo1856(): scala.Int = { /* compiled code */ } + def foo1857(): scala.Int = { /* compiled code */ } + def foo1858(): scala.Int = { /* compiled code */ } + def foo1859(): scala.Int = { /* compiled code */ } + def foo1860(): scala.Int = { /* compiled code */ } + def foo1861(): scala.Int = { /* compiled code */ } + def foo1862(): scala.Int = { /* compiled code */ } + def foo1863(): scala.Int = { /* compiled code */ } + def foo1864(): scala.Int = { /* compiled code */ } + def foo1865(): scala.Int = { /* compiled code */ } + def foo1866(): scala.Int = { /* compiled code */ } + def foo1867(): scala.Int = { /* compiled code */ } + def foo1868(): scala.Int = { /* compiled code */ } + def foo1869(): scala.Int = { /* compiled code */ } + def foo1870(): scala.Int = { /* compiled code */ } + def foo1871(): scala.Int = { /* compiled code */ } + def foo1872(): scala.Int = { /* compiled code */ } + def foo1873(): scala.Int = { /* compiled code */ } + def foo1874(): scala.Int = { /* compiled code */ } + def foo1875(): scala.Int = { /* compiled code */ } + def foo1876(): scala.Int = { /* compiled code */ } + def foo1877(): scala.Int = { /* compiled code */ } + def foo1878(): scala.Int = { /* compiled code */ } + def foo1879(): scala.Int = { /* compiled code */ } + def foo1880(): scala.Int = { /* compiled code */ } + def foo1881(): scala.Int = { /* compiled code */ } + def foo1882(): scala.Int = { /* compiled code */ } + def foo1883(): scala.Int = { /* compiled code */ } + def foo1884(): scala.Int = { /* compiled code */ } + def foo1885(): scala.Int = { /* compiled code */ } + def foo1886(): scala.Int = { /* compiled code */ } + def foo1887(): scala.Int = { /* compiled code */ } + def foo1888(): scala.Int = { /* compiled code */ } + def foo1889(): scala.Int = { /* compiled code */ } + def foo1890(): scala.Int = { /* compiled code */ } + def foo1891(): scala.Int = { /* compiled code */ } + def foo1892(): scala.Int = { /* compiled code */ } + def foo1893(): scala.Int = { /* compiled code */ } + def foo1894(): scala.Int = { /* compiled code */ } + def foo1895(): scala.Int = { /* compiled code */ } + def foo1896(): scala.Int = { /* compiled code */ } + def foo1897(): scala.Int = { /* compiled code */ } + def foo1898(): scala.Int = { /* compiled code */ } + def foo1899(): scala.Int = { /* compiled code */ } + def foo1900(): scala.Int = { /* compiled code */ } + def foo1901(): scala.Int = { /* compiled code */ } + def foo1902(): scala.Int = { /* compiled code */ } + def foo1903(): scala.Int = { /* compiled code */ } + def foo1904(): scala.Int = { /* compiled code */ } + def foo1905(): scala.Int = { /* compiled code */ } + def foo1906(): scala.Int = { /* compiled code */ } + def foo1907(): scala.Int = { /* compiled code */ } + def foo1908(): scala.Int = { /* compiled code */ } + def foo1909(): scala.Int = { /* compiled code */ } + def foo1910(): scala.Int = { /* compiled code */ } + def foo1911(): scala.Int = { /* compiled code */ } + def foo1912(): scala.Int = { /* compiled code */ } + def foo1913(): scala.Int = { /* compiled code */ } + def foo1914(): scala.Int = { /* compiled code */ } + def foo1915(): scala.Int = { /* compiled code */ } + def foo1916(): scala.Int = { /* compiled code */ } + def foo1917(): scala.Int = { /* compiled code */ } + def foo1918(): scala.Int = { /* compiled code */ } + def foo1919(): scala.Int = { /* compiled code */ } + def foo1920(): scala.Int = { /* compiled code */ } + def foo1921(): scala.Int = { /* compiled code */ } + def foo1922(): scala.Int = { /* compiled code */ } + def foo1923(): scala.Int = { /* compiled code */ } + def foo1924(): scala.Int = { /* compiled code */ } + def foo1925(): scala.Int = { /* compiled code */ } + def foo1926(): scala.Int = { /* compiled code */ } + def foo1927(): scala.Int = { /* compiled code */ } + def foo1928(): scala.Int = { /* compiled code */ } + def foo1929(): scala.Int = { /* compiled code */ } + def foo1930(): scala.Int = { /* compiled code */ } + def foo1931(): scala.Int = { /* compiled code */ } + def foo1932(): scala.Int = { /* compiled code */ } + def foo1933(): scala.Int = { /* compiled code */ } + def foo1934(): scala.Int = { /* compiled code */ } + def foo1935(): scala.Int = { /* compiled code */ } + def foo1936(): scala.Int = { /* compiled code */ } + def foo1937(): scala.Int = { /* compiled code */ } + def foo1938(): scala.Int = { /* compiled code */ } + def foo1939(): scala.Int = { /* compiled code */ } + def foo1940(): scala.Int = { /* compiled code */ } + def foo1941(): scala.Int = { /* compiled code */ } + def foo1942(): scala.Int = { /* compiled code */ } + def foo1943(): scala.Int = { /* compiled code */ } + def foo1944(): scala.Int = { /* compiled code */ } + def foo1945(): scala.Int = { /* compiled code */ } + def foo1946(): scala.Int = { /* compiled code */ } + def foo1947(): scala.Int = { /* compiled code */ } + def foo1948(): scala.Int = { /* compiled code */ } + def foo1949(): scala.Int = { /* compiled code */ } + def foo1950(): scala.Int = { /* compiled code */ } + def foo1951(): scala.Int = { /* compiled code */ } + def foo1952(): scala.Int = { /* compiled code */ } + def foo1953(): scala.Int = { /* compiled code */ } + def foo1954(): scala.Int = { /* compiled code */ } + def foo1955(): scala.Int = { /* compiled code */ } + def foo1956(): scala.Int = { /* compiled code */ } + def foo1957(): scala.Int = { /* compiled code */ } + def foo1958(): scala.Int = { /* compiled code */ } + def foo1959(): scala.Int = { /* compiled code */ } + def foo1960(): scala.Int = { /* compiled code */ } + def foo1961(): scala.Int = { /* compiled code */ } + def foo1962(): scala.Int = { /* compiled code */ } + def foo1963(): scala.Int = { /* compiled code */ } + def foo1964(): scala.Int = { /* compiled code */ } + def foo1965(): scala.Int = { /* compiled code */ } + def foo1966(): scala.Int = { /* compiled code */ } + def foo1967(): scala.Int = { /* compiled code */ } + def foo1968(): scala.Int = { /* compiled code */ } + def foo1969(): scala.Int = { /* compiled code */ } + def foo1970(): scala.Int = { /* compiled code */ } + def foo1971(): scala.Int = { /* compiled code */ } + def foo1972(): scala.Int = { /* compiled code */ } + def foo1973(): scala.Int = { /* compiled code */ } + def foo1974(): scala.Int = { /* compiled code */ } + def foo1975(): scala.Int = { /* compiled code */ } + def foo1976(): scala.Int = { /* compiled code */ } + def foo1977(): scala.Int = { /* compiled code */ } + def foo1978(): scala.Int = { /* compiled code */ } + def foo1979(): scala.Int = { /* compiled code */ } + def foo1980(): scala.Int = { /* compiled code */ } + def foo1981(): scala.Int = { /* compiled code */ } + def foo1982(): scala.Int = { /* compiled code */ } + def foo1983(): scala.Int = { /* compiled code */ } + def foo1984(): scala.Int = { /* compiled code */ } + def foo1985(): scala.Int = { /* compiled code */ } + def foo1986(): scala.Int = { /* compiled code */ } + def foo1987(): scala.Int = { /* compiled code */ } + def foo1988(): scala.Int = { /* compiled code */ } + def foo1989(): scala.Int = { /* compiled code */ } + def foo1990(): scala.Int = { /* compiled code */ } + def foo1991(): scala.Int = { /* compiled code */ } + def foo1992(): scala.Int = { /* compiled code */ } + def foo1993(): scala.Int = { /* compiled code */ } + def foo1994(): scala.Int = { /* compiled code */ } + def foo1995(): scala.Int = { /* compiled code */ } + def foo1996(): scala.Int = { /* compiled code */ } + def foo1997(): scala.Int = { /* compiled code */ } + def foo1998(): scala.Int = { /* compiled code */ } + def foo1999(): scala.Int = { /* compiled code */ } + def foo2000(): scala.Int = { /* compiled code */ } + def foo2001(): scala.Int = { /* compiled code */ } + def foo2002(): scala.Int = { /* compiled code */ } + def foo2003(): scala.Int = { /* compiled code */ } + def foo2004(): scala.Int = { /* compiled code */ } + def foo2005(): scala.Int = { /* compiled code */ } + def foo2006(): scala.Int = { /* compiled code */ } + def foo2007(): scala.Int = { /* compiled code */ } + def foo2008(): scala.Int = { /* compiled code */ } + def foo2009(): scala.Int = { /* compiled code */ } + def foo2010(): scala.Int = { /* compiled code */ } + def foo2011(): scala.Int = { /* compiled code */ } + def foo2012(): scala.Int = { /* compiled code */ } + def foo2013(): scala.Int = { /* compiled code */ } + def foo2014(): scala.Int = { /* compiled code */ } + def foo2015(): scala.Int = { /* compiled code */ } + def foo2016(): scala.Int = { /* compiled code */ } + def foo2017(): scala.Int = { /* compiled code */ } + def foo2018(): scala.Int = { /* compiled code */ } + def foo2019(): scala.Int = { /* compiled code */ } + def foo2020(): scala.Int = { /* compiled code */ } + def foo2021(): scala.Int = { /* compiled code */ } + def foo2022(): scala.Int = { /* compiled code */ } + def foo2023(): scala.Int = { /* compiled code */ } + def foo2024(): scala.Int = { /* compiled code */ } + def foo2025(): scala.Int = { /* compiled code */ } + def foo2026(): scala.Int = { /* compiled code */ } + def foo2027(): scala.Int = { /* compiled code */ } + def foo2028(): scala.Int = { /* compiled code */ } + def foo2029(): scala.Int = { /* compiled code */ } + def foo2030(): scala.Int = { /* compiled code */ } + def foo2031(): scala.Int = { /* compiled code */ } + def foo2032(): scala.Int = { /* compiled code */ } + def foo2033(): scala.Int = { /* compiled code */ } + def foo2034(): scala.Int = { /* compiled code */ } + def foo2035(): scala.Int = { /* compiled code */ } + def foo2036(): scala.Int = { /* compiled code */ } + def foo2037(): scala.Int = { /* compiled code */ } + def foo2038(): scala.Int = { /* compiled code */ } + def foo2039(): scala.Int = { /* compiled code */ } + def foo2040(): scala.Int = { /* compiled code */ } + def foo2041(): scala.Int = { /* compiled code */ } + def foo2042(): scala.Int = { /* compiled code */ } + def foo2043(): scala.Int = { /* compiled code */ } + def foo2044(): scala.Int = { /* compiled code */ } + def foo2045(): scala.Int = { /* compiled code */ } + def foo2046(): scala.Int = { /* compiled code */ } + def foo2047(): scala.Int = { /* compiled code */ } + def foo2048(): scala.Int = { /* compiled code */ } + def foo2049(): scala.Int = { /* compiled code */ } + def foo2050(): scala.Int = { /* compiled code */ } + def foo2051(): scala.Int = { /* compiled code */ } + def foo2052(): scala.Int = { /* compiled code */ } + def foo2053(): scala.Int = { /* compiled code */ } + def foo2054(): scala.Int = { /* compiled code */ } + def foo2055(): scala.Int = { /* compiled code */ } + def foo2056(): scala.Int = { /* compiled code */ } + def foo2057(): scala.Int = { /* compiled code */ } + def foo2058(): scala.Int = { /* compiled code */ } + def foo2059(): scala.Int = { /* compiled code */ } + def foo2060(): scala.Int = { /* compiled code */ } + def foo2061(): scala.Int = { /* compiled code */ } + def foo2062(): scala.Int = { /* compiled code */ } + def foo2063(): scala.Int = { /* compiled code */ } + def foo2064(): scala.Int = { /* compiled code */ } + def foo2065(): scala.Int = { /* compiled code */ } + def foo2066(): scala.Int = { /* compiled code */ } + def foo2067(): scala.Int = { /* compiled code */ } + def foo2068(): scala.Int = { /* compiled code */ } + def foo2069(): scala.Int = { /* compiled code */ } + def foo2070(): scala.Int = { /* compiled code */ } + def foo2071(): scala.Int = { /* compiled code */ } + def foo2072(): scala.Int = { /* compiled code */ } + def foo2073(): scala.Int = { /* compiled code */ } + def foo2074(): scala.Int = { /* compiled code */ } + def foo2075(): scala.Int = { /* compiled code */ } + def foo2076(): scala.Int = { /* compiled code */ } + def foo2077(): scala.Int = { /* compiled code */ } + def foo2078(): scala.Int = { /* compiled code */ } + def foo2079(): scala.Int = { /* compiled code */ } + def foo2080(): scala.Int = { /* compiled code */ } + def foo2081(): scala.Int = { /* compiled code */ } + def foo2082(): scala.Int = { /* compiled code */ } + def foo2083(): scala.Int = { /* compiled code */ } + def foo2084(): scala.Int = { /* compiled code */ } + def foo2085(): scala.Int = { /* compiled code */ } + def foo2086(): scala.Int = { /* compiled code */ } + def foo2087(): scala.Int = { /* compiled code */ } + def foo2088(): scala.Int = { /* compiled code */ } + def foo2089(): scala.Int = { /* compiled code */ } + def foo2090(): scala.Int = { /* compiled code */ } + def foo2091(): scala.Int = { /* compiled code */ } + def foo2092(): scala.Int = { /* compiled code */ } + def foo2093(): scala.Int = { /* compiled code */ } + def foo2094(): scala.Int = { /* compiled code */ } + def foo2095(): scala.Int = { /* compiled code */ } + def foo2096(): scala.Int = { /* compiled code */ } + def foo2097(): scala.Int = { /* compiled code */ } + def foo2098(): scala.Int = { /* compiled code */ } + def foo2099(): scala.Int = { /* compiled code */ } + def foo2100(): scala.Int = { /* compiled code */ } + def foo2101(): scala.Int = { /* compiled code */ } + def foo2102(): scala.Int = { /* compiled code */ } + def foo2103(): scala.Int = { /* compiled code */ } + def foo2104(): scala.Int = { /* compiled code */ } + def foo2105(): scala.Int = { /* compiled code */ } + def foo2106(): scala.Int = { /* compiled code */ } + def foo2107(): scala.Int = { /* compiled code */ } + def foo2108(): scala.Int = { /* compiled code */ } + def foo2109(): scala.Int = { /* compiled code */ } + def foo2110(): scala.Int = { /* compiled code */ } + def foo2111(): scala.Int = { /* compiled code */ } + def foo2112(): scala.Int = { /* compiled code */ } + def foo2113(): scala.Int = { /* compiled code */ } + def foo2114(): scala.Int = { /* compiled code */ } + def foo2115(): scala.Int = { /* compiled code */ } + def foo2116(): scala.Int = { /* compiled code */ } + def foo2117(): scala.Int = { /* compiled code */ } + def foo2118(): scala.Int = { /* compiled code */ } + def foo2119(): scala.Int = { /* compiled code */ } + def foo2120(): scala.Int = { /* compiled code */ } + def foo2121(): scala.Int = { /* compiled code */ } + def foo2122(): scala.Int = { /* compiled code */ } + def foo2123(): scala.Int = { /* compiled code */ } + def foo2124(): scala.Int = { /* compiled code */ } + def foo2125(): scala.Int = { /* compiled code */ } + def foo2126(): scala.Int = { /* compiled code */ } + def foo2127(): scala.Int = { /* compiled code */ } + def foo2128(): scala.Int = { /* compiled code */ } + def foo2129(): scala.Int = { /* compiled code */ } + def foo2130(): scala.Int = { /* compiled code */ } + def foo2131(): scala.Int = { /* compiled code */ } + def foo2132(): scala.Int = { /* compiled code */ } + def foo2133(): scala.Int = { /* compiled code */ } + def foo2134(): scala.Int = { /* compiled code */ } + def foo2135(): scala.Int = { /* compiled code */ } + def foo2136(): scala.Int = { /* compiled code */ } + def foo2137(): scala.Int = { /* compiled code */ } + def foo2138(): scala.Int = { /* compiled code */ } + def foo2139(): scala.Int = { /* compiled code */ } + def foo2140(): scala.Int = { /* compiled code */ } + def foo2141(): scala.Int = { /* compiled code */ } + def foo2142(): scala.Int = { /* compiled code */ } + def foo2143(): scala.Int = { /* compiled code */ } + def foo2144(): scala.Int = { /* compiled code */ } + def foo2145(): scala.Int = { /* compiled code */ } + def foo2146(): scala.Int = { /* compiled code */ } + def foo2147(): scala.Int = { /* compiled code */ } + def foo2148(): scala.Int = { /* compiled code */ } + def foo2149(): scala.Int = { /* compiled code */ } + def foo2150(): scala.Int = { /* compiled code */ } + def foo2151(): scala.Int = { /* compiled code */ } + def foo2152(): scala.Int = { /* compiled code */ } + def foo2153(): scala.Int = { /* compiled code */ } + def foo2154(): scala.Int = { /* compiled code */ } + def foo2155(): scala.Int = { /* compiled code */ } + def foo2156(): scala.Int = { /* compiled code */ } + def foo2157(): scala.Int = { /* compiled code */ } + def foo2158(): scala.Int = { /* compiled code */ } + def foo2159(): scala.Int = { /* compiled code */ } + def foo2160(): scala.Int = { /* compiled code */ } + def foo2161(): scala.Int = { /* compiled code */ } + def foo2162(): scala.Int = { /* compiled code */ } + def foo2163(): scala.Int = { /* compiled code */ } + def foo2164(): scala.Int = { /* compiled code */ } + def foo2165(): scala.Int = { /* compiled code */ } + def foo2166(): scala.Int = { /* compiled code */ } + def foo2167(): scala.Int = { /* compiled code */ } + def foo2168(): scala.Int = { /* compiled code */ } + def foo2169(): scala.Int = { /* compiled code */ } + def foo2170(): scala.Int = { /* compiled code */ } + def foo2171(): scala.Int = { /* compiled code */ } + def foo2172(): scala.Int = { /* compiled code */ } + def foo2173(): scala.Int = { /* compiled code */ } + def foo2174(): scala.Int = { /* compiled code */ } + def foo2175(): scala.Int = { /* compiled code */ } + def foo2176(): scala.Int = { /* compiled code */ } + def foo2177(): scala.Int = { /* compiled code */ } + def foo2178(): scala.Int = { /* compiled code */ } + def foo2179(): scala.Int = { /* compiled code */ } + def foo2180(): scala.Int = { /* compiled code */ } + def foo2181(): scala.Int = { /* compiled code */ } + def foo2182(): scala.Int = { /* compiled code */ } + def foo2183(): scala.Int = { /* compiled code */ } + def foo2184(): scala.Int = { /* compiled code */ } + def foo2185(): scala.Int = { /* compiled code */ } + def foo2186(): scala.Int = { /* compiled code */ } + def foo2187(): scala.Int = { /* compiled code */ } + def foo2188(): scala.Int = { /* compiled code */ } + def foo2189(): scala.Int = { /* compiled code */ } + def foo2190(): scala.Int = { /* compiled code */ } + def foo2191(): scala.Int = { /* compiled code */ } + def foo2192(): scala.Int = { /* compiled code */ } + def foo2193(): scala.Int = { /* compiled code */ } + def foo2194(): scala.Int = { /* compiled code */ } + def foo2195(): scala.Int = { /* compiled code */ } + def foo2196(): scala.Int = { /* compiled code */ } + def foo2197(): scala.Int = { /* compiled code */ } + def foo2198(): scala.Int = { /* compiled code */ } + def foo2199(): scala.Int = { /* compiled code */ } + def foo2200(): scala.Int = { /* compiled code */ } + def foo2201(): scala.Int = { /* compiled code */ } + def foo2202(): scala.Int = { /* compiled code */ } + def foo2203(): scala.Int = { /* compiled code */ } + def foo2204(): scala.Int = { /* compiled code */ } + def foo2205(): scala.Int = { /* compiled code */ } + def foo2206(): scala.Int = { /* compiled code */ } + def foo2207(): scala.Int = { /* compiled code */ } + def foo2208(): scala.Int = { /* compiled code */ } + def foo2209(): scala.Int = { /* compiled code */ } + def foo2210(): scala.Int = { /* compiled code */ } + def foo2211(): scala.Int = { /* compiled code */ } + def foo2212(): scala.Int = { /* compiled code */ } + def foo2213(): scala.Int = { /* compiled code */ } + def foo2214(): scala.Int = { /* compiled code */ } + def foo2215(): scala.Int = { /* compiled code */ } + def foo2216(): scala.Int = { /* compiled code */ } + def foo2217(): scala.Int = { /* compiled code */ } + def foo2218(): scala.Int = { /* compiled code */ } + def foo2219(): scala.Int = { /* compiled code */ } + def foo2220(): scala.Int = { /* compiled code */ } + def foo2221(): scala.Int = { /* compiled code */ } + def foo2222(): scala.Int = { /* compiled code */ } + def foo2223(): scala.Int = { /* compiled code */ } + def foo2224(): scala.Int = { /* compiled code */ } + def foo2225(): scala.Int = { /* compiled code */ } + def foo2226(): scala.Int = { /* compiled code */ } + def foo2227(): scala.Int = { /* compiled code */ } + def foo2228(): scala.Int = { /* compiled code */ } + def foo2229(): scala.Int = { /* compiled code */ } + def foo2230(): scala.Int = { /* compiled code */ } + def foo2231(): scala.Int = { /* compiled code */ } + def foo2232(): scala.Int = { /* compiled code */ } + def foo2233(): scala.Int = { /* compiled code */ } + def foo2234(): scala.Int = { /* compiled code */ } + def foo2235(): scala.Int = { /* compiled code */ } + def foo2236(): scala.Int = { /* compiled code */ } + def foo2237(): scala.Int = { /* compiled code */ } + def foo2238(): scala.Int = { /* compiled code */ } + def foo2239(): scala.Int = { /* compiled code */ } + def foo2240(): scala.Int = { /* compiled code */ } + def foo2241(): scala.Int = { /* compiled code */ } + def foo2242(): scala.Int = { /* compiled code */ } + def foo2243(): scala.Int = { /* compiled code */ } + def foo2244(): scala.Int = { /* compiled code */ } + def foo2245(): scala.Int = { /* compiled code */ } + def foo2246(): scala.Int = { /* compiled code */ } + def foo2247(): scala.Int = { /* compiled code */ } + def foo2248(): scala.Int = { /* compiled code */ } + def foo2249(): scala.Int = { /* compiled code */ } + def foo2250(): scala.Int = { /* compiled code */ } + def foo2251(): scala.Int = { /* compiled code */ } + def foo2252(): scala.Int = { /* compiled code */ } + def foo2253(): scala.Int = { /* compiled code */ } + def foo2254(): scala.Int = { /* compiled code */ } + def foo2255(): scala.Int = { /* compiled code */ } + def foo2256(): scala.Int = { /* compiled code */ } + def foo2257(): scala.Int = { /* compiled code */ } + def foo2258(): scala.Int = { /* compiled code */ } + def foo2259(): scala.Int = { /* compiled code */ } + def foo2260(): scala.Int = { /* compiled code */ } + def foo2261(): scala.Int = { /* compiled code */ } + def foo2262(): scala.Int = { /* compiled code */ } + def foo2263(): scala.Int = { /* compiled code */ } + def foo2264(): scala.Int = { /* compiled code */ } + def foo2265(): scala.Int = { /* compiled code */ } + def foo2266(): scala.Int = { /* compiled code */ } + def foo2267(): scala.Int = { /* compiled code */ } + def foo2268(): scala.Int = { /* compiled code */ } + def foo2269(): scala.Int = { /* compiled code */ } + def foo2270(): scala.Int = { /* compiled code */ } + def foo2271(): scala.Int = { /* compiled code */ } + def foo2272(): scala.Int = { /* compiled code */ } + def foo2273(): scala.Int = { /* compiled code */ } + def foo2274(): scala.Int = { /* compiled code */ } + def foo2275(): scala.Int = { /* compiled code */ } + def foo2276(): scala.Int = { /* compiled code */ } + def foo2277(): scala.Int = { /* compiled code */ } + def foo2278(): scala.Int = { /* compiled code */ } + def foo2279(): scala.Int = { /* compiled code */ } + def foo2280(): scala.Int = { /* compiled code */ } + def foo2281(): scala.Int = { /* compiled code */ } + def foo2282(): scala.Int = { /* compiled code */ } + def foo2283(): scala.Int = { /* compiled code */ } + def foo2284(): scala.Int = { /* compiled code */ } + def foo2285(): scala.Int = { /* compiled code */ } + def foo2286(): scala.Int = { /* compiled code */ } + def foo2287(): scala.Int = { /* compiled code */ } + def foo2288(): scala.Int = { /* compiled code */ } + def foo2289(): scala.Int = { /* compiled code */ } + def foo2290(): scala.Int = { /* compiled code */ } + def foo2291(): scala.Int = { /* compiled code */ } + def foo2292(): scala.Int = { /* compiled code */ } + def foo2293(): scala.Int = { /* compiled code */ } + def foo2294(): scala.Int = { /* compiled code */ } + def foo2295(): scala.Int = { /* compiled code */ } + def foo2296(): scala.Int = { /* compiled code */ } + def foo2297(): scala.Int = { /* compiled code */ } + def foo2298(): scala.Int = { /* compiled code */ } + def foo2299(): scala.Int = { /* compiled code */ } + def foo2300(): scala.Int = { /* compiled code */ } + def foo2301(): scala.Int = { /* compiled code */ } + def foo2302(): scala.Int = { /* compiled code */ } + def foo2303(): scala.Int = { /* compiled code */ } + def foo2304(): scala.Int = { /* compiled code */ } + def foo2305(): scala.Int = { /* compiled code */ } + def foo2306(): scala.Int = { /* compiled code */ } + def foo2307(): scala.Int = { /* compiled code */ } + def foo2308(): scala.Int = { /* compiled code */ } + def foo2309(): scala.Int = { /* compiled code */ } + def foo2310(): scala.Int = { /* compiled code */ } + def foo2311(): scala.Int = { /* compiled code */ } + def foo2312(): scala.Int = { /* compiled code */ } + def foo2313(): scala.Int = { /* compiled code */ } + def foo2314(): scala.Int = { /* compiled code */ } + def foo2315(): scala.Int = { /* compiled code */ } + def foo2316(): scala.Int = { /* compiled code */ } + def foo2317(): scala.Int = { /* compiled code */ } + def foo2318(): scala.Int = { /* compiled code */ } + def foo2319(): scala.Int = { /* compiled code */ } + def foo2320(): scala.Int = { /* compiled code */ } + def foo2321(): scala.Int = { /* compiled code */ } + def foo2322(): scala.Int = { /* compiled code */ } + def foo2323(): scala.Int = { /* compiled code */ } + def foo2324(): scala.Int = { /* compiled code */ } + def foo2325(): scala.Int = { /* compiled code */ } + def foo2326(): scala.Int = { /* compiled code */ } + def foo2327(): scala.Int = { /* compiled code */ } + def foo2328(): scala.Int = { /* compiled code */ } + def foo2329(): scala.Int = { /* compiled code */ } + def foo2330(): scala.Int = { /* compiled code */ } + def foo2331(): scala.Int = { /* compiled code */ } + def foo2332(): scala.Int = { /* compiled code */ } + def foo2333(): scala.Int = { /* compiled code */ } + def foo2334(): scala.Int = { /* compiled code */ } + def foo2335(): scala.Int = { /* compiled code */ } + def foo2336(): scala.Int = { /* compiled code */ } + def foo2337(): scala.Int = { /* compiled code */ } + def foo2338(): scala.Int = { /* compiled code */ } + def foo2339(): scala.Int = { /* compiled code */ } + def foo2340(): scala.Int = { /* compiled code */ } + def foo2341(): scala.Int = { /* compiled code */ } + def foo2342(): scala.Int = { /* compiled code */ } + def foo2343(): scala.Int = { /* compiled code */ } + def foo2344(): scala.Int = { /* compiled code */ } + def foo2345(): scala.Int = { /* compiled code */ } + def foo2346(): scala.Int = { /* compiled code */ } + def foo2347(): scala.Int = { /* compiled code */ } + def foo2348(): scala.Int = { /* compiled code */ } + def foo2349(): scala.Int = { /* compiled code */ } + def foo2350(): scala.Int = { /* compiled code */ } + def foo2351(): scala.Int = { /* compiled code */ } + def foo2352(): scala.Int = { /* compiled code */ } + def foo2353(): scala.Int = { /* compiled code */ } + def foo2354(): scala.Int = { /* compiled code */ } + def foo2355(): scala.Int = { /* compiled code */ } + def foo2356(): scala.Int = { /* compiled code */ } + def foo2357(): scala.Int = { /* compiled code */ } + def foo2358(): scala.Int = { /* compiled code */ } + def foo2359(): scala.Int = { /* compiled code */ } + def foo2360(): scala.Int = { /* compiled code */ } + def foo2361(): scala.Int = { /* compiled code */ } + def foo2362(): scala.Int = { /* compiled code */ } + def foo2363(): scala.Int = { /* compiled code */ } + def foo2364(): scala.Int = { /* compiled code */ } + def foo2365(): scala.Int = { /* compiled code */ } + def foo2366(): scala.Int = { /* compiled code */ } + def foo2367(): scala.Int = { /* compiled code */ } + def foo2368(): scala.Int = { /* compiled code */ } + def foo2369(): scala.Int = { /* compiled code */ } + def foo2370(): scala.Int = { /* compiled code */ } + def foo2371(): scala.Int = { /* compiled code */ } + def foo2372(): scala.Int = { /* compiled code */ } + def foo2373(): scala.Int = { /* compiled code */ } + def foo2374(): scala.Int = { /* compiled code */ } + def foo2375(): scala.Int = { /* compiled code */ } + def foo2376(): scala.Int = { /* compiled code */ } + def foo2377(): scala.Int = { /* compiled code */ } + def foo2378(): scala.Int = { /* compiled code */ } + def foo2379(): scala.Int = { /* compiled code */ } + def foo2380(): scala.Int = { /* compiled code */ } + def foo2381(): scala.Int = { /* compiled code */ } + def foo2382(): scala.Int = { /* compiled code */ } + def foo2383(): scala.Int = { /* compiled code */ } + def foo2384(): scala.Int = { /* compiled code */ } + def foo2385(): scala.Int = { /* compiled code */ } + def foo2386(): scala.Int = { /* compiled code */ } + def foo2387(): scala.Int = { /* compiled code */ } + def foo2388(): scala.Int = { /* compiled code */ } + def foo2389(): scala.Int = { /* compiled code */ } + def foo2390(): scala.Int = { /* compiled code */ } + def foo2391(): scala.Int = { /* compiled code */ } + def foo2392(): scala.Int = { /* compiled code */ } + def foo2393(): scala.Int = { /* compiled code */ } + def foo2394(): scala.Int = { /* compiled code */ } + def foo2395(): scala.Int = { /* compiled code */ } + def foo2396(): scala.Int = { /* compiled code */ } + def foo2397(): scala.Int = { /* compiled code */ } + def foo2398(): scala.Int = { /* compiled code */ } + def foo2399(): scala.Int = { /* compiled code */ } + def foo2400(): scala.Int = { /* compiled code */ } + def foo2401(): scala.Int = { /* compiled code */ } + def foo2402(): scala.Int = { /* compiled code */ } + def foo2403(): scala.Int = { /* compiled code */ } + def foo2404(): scala.Int = { /* compiled code */ } + def foo2405(): scala.Int = { /* compiled code */ } + def foo2406(): scala.Int = { /* compiled code */ } + def foo2407(): scala.Int = { /* compiled code */ } + def foo2408(): scala.Int = { /* compiled code */ } + def foo2409(): scala.Int = { /* compiled code */ } + def foo2410(): scala.Int = { /* compiled code */ } + def foo2411(): scala.Int = { /* compiled code */ } + def foo2412(): scala.Int = { /* compiled code */ } + def foo2413(): scala.Int = { /* compiled code */ } + def foo2414(): scala.Int = { /* compiled code */ } + def foo2415(): scala.Int = { /* compiled code */ } + def foo2416(): scala.Int = { /* compiled code */ } + def foo2417(): scala.Int = { /* compiled code */ } + def foo2418(): scala.Int = { /* compiled code */ } + def foo2419(): scala.Int = { /* compiled code */ } + def foo2420(): scala.Int = { /* compiled code */ } + def foo2421(): scala.Int = { /* compiled code */ } + def foo2422(): scala.Int = { /* compiled code */ } + def foo2423(): scala.Int = { /* compiled code */ } + def foo2424(): scala.Int = { /* compiled code */ } + def foo2425(): scala.Int = { /* compiled code */ } + def foo2426(): scala.Int = { /* compiled code */ } + def foo2427(): scala.Int = { /* compiled code */ } + def foo2428(): scala.Int = { /* compiled code */ } + def foo2429(): scala.Int = { /* compiled code */ } + def foo2430(): scala.Int = { /* compiled code */ } + def foo2431(): scala.Int = { /* compiled code */ } + def foo2432(): scala.Int = { /* compiled code */ } + def foo2433(): scala.Int = { /* compiled code */ } + def foo2434(): scala.Int = { /* compiled code */ } + def foo2435(): scala.Int = { /* compiled code */ } + def foo2436(): scala.Int = { /* compiled code */ } + def foo2437(): scala.Int = { /* compiled code */ } + def foo2438(): scala.Int = { /* compiled code */ } + def foo2439(): scala.Int = { /* compiled code */ } + def foo2440(): scala.Int = { /* compiled code */ } + def foo2441(): scala.Int = { /* compiled code */ } + def foo2442(): scala.Int = { /* compiled code */ } + def foo2443(): scala.Int = { /* compiled code */ } + def foo2444(): scala.Int = { /* compiled code */ } + def foo2445(): scala.Int = { /* compiled code */ } + def foo2446(): scala.Int = { /* compiled code */ } + def foo2447(): scala.Int = { /* compiled code */ } + def foo2448(): scala.Int = { /* compiled code */ } + def foo2449(): scala.Int = { /* compiled code */ } + def foo2450(): scala.Int = { /* compiled code */ } + def foo2451(): scala.Int = { /* compiled code */ } + def foo2452(): scala.Int = { /* compiled code */ } + def foo2453(): scala.Int = { /* compiled code */ } + def foo2454(): scala.Int = { /* compiled code */ } + def foo2455(): scala.Int = { /* compiled code */ } + def foo2456(): scala.Int = { /* compiled code */ } + def foo2457(): scala.Int = { /* compiled code */ } + def foo2458(): scala.Int = { /* compiled code */ } + def foo2459(): scala.Int = { /* compiled code */ } + def foo2460(): scala.Int = { /* compiled code */ } + def foo2461(): scala.Int = { /* compiled code */ } + def foo2462(): scala.Int = { /* compiled code */ } + def foo2463(): scala.Int = { /* compiled code */ } + def foo2464(): scala.Int = { /* compiled code */ } + def foo2465(): scala.Int = { /* compiled code */ } + def foo2466(): scala.Int = { /* compiled code */ } + def foo2467(): scala.Int = { /* compiled code */ } + def foo2468(): scala.Int = { /* compiled code */ } + def foo2469(): scala.Int = { /* compiled code */ } + def foo2470(): scala.Int = { /* compiled code */ } + def foo2471(): scala.Int = { /* compiled code */ } + def foo2472(): scala.Int = { /* compiled code */ } + def foo2473(): scala.Int = { /* compiled code */ } + def foo2474(): scala.Int = { /* compiled code */ } + def foo2475(): scala.Int = { /* compiled code */ } + def foo2476(): scala.Int = { /* compiled code */ } + def foo2477(): scala.Int = { /* compiled code */ } + def foo2478(): scala.Int = { /* compiled code */ } + def foo2479(): scala.Int = { /* compiled code */ } + def foo2480(): scala.Int = { /* compiled code */ } + def foo2481(): scala.Int = { /* compiled code */ } + def foo2482(): scala.Int = { /* compiled code */ } + def foo2483(): scala.Int = { /* compiled code */ } + def foo2484(): scala.Int = { /* compiled code */ } + def foo2485(): scala.Int = { /* compiled code */ } + def foo2486(): scala.Int = { /* compiled code */ } + def foo2487(): scala.Int = { /* compiled code */ } + def foo2488(): scala.Int = { /* compiled code */ } + def foo2489(): scala.Int = { /* compiled code */ } + def foo2490(): scala.Int = { /* compiled code */ } + def foo2491(): scala.Int = { /* compiled code */ } + def foo2492(): scala.Int = { /* compiled code */ } + def foo2493(): scala.Int = { /* compiled code */ } + def foo2494(): scala.Int = { /* compiled code */ } + def foo2495(): scala.Int = { /* compiled code */ } + def foo2496(): scala.Int = { /* compiled code */ } + def foo2497(): scala.Int = { /* compiled code */ } + def foo2498(): scala.Int = { /* compiled code */ } + def foo2499(): scala.Int = { /* compiled code */ } + def foo2500(): scala.Int = { /* compiled code */ } + def foo2501(): scala.Int = { /* compiled code */ } + def foo2502(): scala.Int = { /* compiled code */ } + def foo2503(): scala.Int = { /* compiled code */ } + def foo2504(): scala.Int = { /* compiled code */ } + def foo2505(): scala.Int = { /* compiled code */ } + def foo2506(): scala.Int = { /* compiled code */ } + def foo2507(): scala.Int = { /* compiled code */ } + def foo2508(): scala.Int = { /* compiled code */ } + def foo2509(): scala.Int = { /* compiled code */ } + def foo2510(): scala.Int = { /* compiled code */ } + def foo2511(): scala.Int = { /* compiled code */ } + def foo2512(): scala.Int = { /* compiled code */ } + def foo2513(): scala.Int = { /* compiled code */ } + def foo2514(): scala.Int = { /* compiled code */ } + def foo2515(): scala.Int = { /* compiled code */ } + def foo2516(): scala.Int = { /* compiled code */ } + def foo2517(): scala.Int = { /* compiled code */ } + def foo2518(): scala.Int = { /* compiled code */ } + def foo2519(): scala.Int = { /* compiled code */ } + def foo2520(): scala.Int = { /* compiled code */ } + def foo2521(): scala.Int = { /* compiled code */ } + def foo2522(): scala.Int = { /* compiled code */ } + def foo2523(): scala.Int = { /* compiled code */ } + def foo2524(): scala.Int = { /* compiled code */ } + def foo2525(): scala.Int = { /* compiled code */ } + def foo2526(): scala.Int = { /* compiled code */ } + def foo2527(): scala.Int = { /* compiled code */ } + def foo2528(): scala.Int = { /* compiled code */ } + def foo2529(): scala.Int = { /* compiled code */ } + def foo2530(): scala.Int = { /* compiled code */ } + def foo2531(): scala.Int = { /* compiled code */ } + def foo2532(): scala.Int = { /* compiled code */ } + def foo2533(): scala.Int = { /* compiled code */ } + def foo2534(): scala.Int = { /* compiled code */ } + def foo2535(): scala.Int = { /* compiled code */ } + def foo2536(): scala.Int = { /* compiled code */ } + def foo2537(): scala.Int = { /* compiled code */ } + def foo2538(): scala.Int = { /* compiled code */ } + def foo2539(): scala.Int = { /* compiled code */ } + def foo2540(): scala.Int = { /* compiled code */ } + def foo2541(): scala.Int = { /* compiled code */ } + def foo2542(): scala.Int = { /* compiled code */ } + def foo2543(): scala.Int = { /* compiled code */ } + def foo2544(): scala.Int = { /* compiled code */ } + def foo2545(): scala.Int = { /* compiled code */ } + def foo2546(): scala.Int = { /* compiled code */ } + def foo2547(): scala.Int = { /* compiled code */ } + def foo2548(): scala.Int = { /* compiled code */ } + def foo2549(): scala.Int = { /* compiled code */ } + def foo2550(): scala.Int = { /* compiled code */ } + def foo2551(): scala.Int = { /* compiled code */ } + def foo2552(): scala.Int = { /* compiled code */ } + def foo2553(): scala.Int = { /* compiled code */ } + def foo2554(): scala.Int = { /* compiled code */ } + def foo2555(): scala.Int = { /* compiled code */ } + def foo2556(): scala.Int = { /* compiled code */ } + def foo2557(): scala.Int = { /* compiled code */ } + def foo2558(): scala.Int = { /* compiled code */ } + def foo2559(): scala.Int = { /* compiled code */ } + def foo2560(): scala.Int = { /* compiled code */ } + def foo2561(): scala.Int = { /* compiled code */ } + def foo2562(): scala.Int = { /* compiled code */ } + def foo2563(): scala.Int = { /* compiled code */ } + def foo2564(): scala.Int = { /* compiled code */ } + def foo2565(): scala.Int = { /* compiled code */ } + def foo2566(): scala.Int = { /* compiled code */ } + def foo2567(): scala.Int = { /* compiled code */ } + def foo2568(): scala.Int = { /* compiled code */ } + def foo2569(): scala.Int = { /* compiled code */ } + def foo2570(): scala.Int = { /* compiled code */ } + def foo2571(): scala.Int = { /* compiled code */ } + def foo2572(): scala.Int = { /* compiled code */ } + def foo2573(): scala.Int = { /* compiled code */ } + def foo2574(): scala.Int = { /* compiled code */ } + def foo2575(): scala.Int = { /* compiled code */ } + def foo2576(): scala.Int = { /* compiled code */ } + def foo2577(): scala.Int = { /* compiled code */ } + def foo2578(): scala.Int = { /* compiled code */ } + def foo2579(): scala.Int = { /* compiled code */ } + def foo2580(): scala.Int = { /* compiled code */ } + def foo2581(): scala.Int = { /* compiled code */ } + def foo2582(): scala.Int = { /* compiled code */ } + def foo2583(): scala.Int = { /* compiled code */ } + def foo2584(): scala.Int = { /* compiled code */ } + def foo2585(): scala.Int = { /* compiled code */ } + def foo2586(): scala.Int = { /* compiled code */ } + def foo2587(): scala.Int = { /* compiled code */ } + def foo2588(): scala.Int = { /* compiled code */ } + def foo2589(): scala.Int = { /* compiled code */ } + def foo2590(): scala.Int = { /* compiled code */ } + def foo2591(): scala.Int = { /* compiled code */ } + def foo2592(): scala.Int = { /* compiled code */ } + def foo2593(): scala.Int = { /* compiled code */ } + def foo2594(): scala.Int = { /* compiled code */ } + def foo2595(): scala.Int = { /* compiled code */ } + def foo2596(): scala.Int = { /* compiled code */ } + def foo2597(): scala.Int = { /* compiled code */ } + def foo2598(): scala.Int = { /* compiled code */ } + def foo2599(): scala.Int = { /* compiled code */ } + def foo2600(): scala.Int = { /* compiled code */ } + def foo2601(): scala.Int = { /* compiled code */ } + def foo2602(): scala.Int = { /* compiled code */ } + def foo2603(): scala.Int = { /* compiled code */ } + def foo2604(): scala.Int = { /* compiled code */ } + def foo2605(): scala.Int = { /* compiled code */ } + def foo2606(): scala.Int = { /* compiled code */ } + def foo2607(): scala.Int = { /* compiled code */ } + def foo2608(): scala.Int = { /* compiled code */ } + def foo2609(): scala.Int = { /* compiled code */ } + def foo2610(): scala.Int = { /* compiled code */ } + def foo2611(): scala.Int = { /* compiled code */ } + def foo2612(): scala.Int = { /* compiled code */ } + def foo2613(): scala.Int = { /* compiled code */ } + def foo2614(): scala.Int = { /* compiled code */ } + def foo2615(): scala.Int = { /* compiled code */ } + def foo2616(): scala.Int = { /* compiled code */ } + def foo2617(): scala.Int = { /* compiled code */ } + def foo2618(): scala.Int = { /* compiled code */ } + def foo2619(): scala.Int = { /* compiled code */ } + def foo2620(): scala.Int = { /* compiled code */ } + def foo2621(): scala.Int = { /* compiled code */ } + def foo2622(): scala.Int = { /* compiled code */ } + def foo2623(): scala.Int = { /* compiled code */ } + def foo2624(): scala.Int = { /* compiled code */ } + def foo2625(): scala.Int = { /* compiled code */ } + def foo2626(): scala.Int = { /* compiled code */ } + def foo2627(): scala.Int = { /* compiled code */ } + def foo2628(): scala.Int = { /* compiled code */ } + def foo2629(): scala.Int = { /* compiled code */ } + def foo2630(): scala.Int = { /* compiled code */ } + def foo2631(): scala.Int = { /* compiled code */ } + def foo2632(): scala.Int = { /* compiled code */ } + def foo2633(): scala.Int = { /* compiled code */ } + def foo2634(): scala.Int = { /* compiled code */ } + def foo2635(): scala.Int = { /* compiled code */ } + def foo2636(): scala.Int = { /* compiled code */ } + def foo2637(): scala.Int = { /* compiled code */ } + def foo2638(): scala.Int = { /* compiled code */ } + def foo2639(): scala.Int = { /* compiled code */ } + def foo2640(): scala.Int = { /* compiled code */ } + def foo2641(): scala.Int = { /* compiled code */ } + def foo2642(): scala.Int = { /* compiled code */ } + def foo2643(): scala.Int = { /* compiled code */ } + def foo2644(): scala.Int = { /* compiled code */ } + def foo2645(): scala.Int = { /* compiled code */ } + def foo2646(): scala.Int = { /* compiled code */ } + def foo2647(): scala.Int = { /* compiled code */ } + def foo2648(): scala.Int = { /* compiled code */ } + def foo2649(): scala.Int = { /* compiled code */ } + def foo2650(): scala.Int = { /* compiled code */ } + def foo2651(): scala.Int = { /* compiled code */ } + def foo2652(): scala.Int = { /* compiled code */ } + def foo2653(): scala.Int = { /* compiled code */ } + def foo2654(): scala.Int = { /* compiled code */ } + def foo2655(): scala.Int = { /* compiled code */ } + def foo2656(): scala.Int = { /* compiled code */ } + def foo2657(): scala.Int = { /* compiled code */ } + def foo2658(): scala.Int = { /* compiled code */ } + def foo2659(): scala.Int = { /* compiled code */ } + def foo2660(): scala.Int = { /* compiled code */ } + def foo2661(): scala.Int = { /* compiled code */ } + def foo2662(): scala.Int = { /* compiled code */ } + def foo2663(): scala.Int = { /* compiled code */ } + def foo2664(): scala.Int = { /* compiled code */ } + def foo2665(): scala.Int = { /* compiled code */ } + def foo2666(): scala.Int = { /* compiled code */ } + def foo2667(): scala.Int = { /* compiled code */ } + def foo2668(): scala.Int = { /* compiled code */ } + def foo2669(): scala.Int = { /* compiled code */ } + def foo2670(): scala.Int = { /* compiled code */ } + def foo2671(): scala.Int = { /* compiled code */ } + def foo2672(): scala.Int = { /* compiled code */ } + def foo2673(): scala.Int = { /* compiled code */ } + def foo2674(): scala.Int = { /* compiled code */ } + def foo2675(): scala.Int = { /* compiled code */ } + def foo2676(): scala.Int = { /* compiled code */ } + def foo2677(): scala.Int = { /* compiled code */ } + def foo2678(): scala.Int = { /* compiled code */ } + def foo2679(): scala.Int = { /* compiled code */ } + def foo2680(): scala.Int = { /* compiled code */ } + def foo2681(): scala.Int = { /* compiled code */ } + def foo2682(): scala.Int = { /* compiled code */ } + def foo2683(): scala.Int = { /* compiled code */ } + def foo2684(): scala.Int = { /* compiled code */ } + def foo2685(): scala.Int = { /* compiled code */ } + def foo2686(): scala.Int = { /* compiled code */ } + def foo2687(): scala.Int = { /* compiled code */ } + def foo2688(): scala.Int = { /* compiled code */ } + def foo2689(): scala.Int = { /* compiled code */ } + def foo2690(): scala.Int = { /* compiled code */ } + def foo2691(): scala.Int = { /* compiled code */ } + def foo2692(): scala.Int = { /* compiled code */ } + def foo2693(): scala.Int = { /* compiled code */ } + def foo2694(): scala.Int = { /* compiled code */ } + def foo2695(): scala.Int = { /* compiled code */ } + def foo2696(): scala.Int = { /* compiled code */ } + def foo2697(): scala.Int = { /* compiled code */ } + def foo2698(): scala.Int = { /* compiled code */ } + def foo2699(): scala.Int = { /* compiled code */ } + def foo2700(): scala.Int = { /* compiled code */ } + def foo2701(): scala.Int = { /* compiled code */ } + def foo2702(): scala.Int = { /* compiled code */ } + def foo2703(): scala.Int = { /* compiled code */ } + def foo2704(): scala.Int = { /* compiled code */ } + def foo2705(): scala.Int = { /* compiled code */ } + def foo2706(): scala.Int = { /* compiled code */ } + def foo2707(): scala.Int = { /* compiled code */ } + def foo2708(): scala.Int = { /* compiled code */ } + def foo2709(): scala.Int = { /* compiled code */ } + def foo2710(): scala.Int = { /* compiled code */ } + def foo2711(): scala.Int = { /* compiled code */ } + def foo2712(): scala.Int = { /* compiled code */ } + def foo2713(): scala.Int = { /* compiled code */ } + def foo2714(): scala.Int = { /* compiled code */ } + def foo2715(): scala.Int = { /* compiled code */ } + def foo2716(): scala.Int = { /* compiled code */ } + def foo2717(): scala.Int = { /* compiled code */ } + def foo2718(): scala.Int = { /* compiled code */ } + def foo2719(): scala.Int = { /* compiled code */ } + def foo2720(): scala.Int = { /* compiled code */ } + def foo2721(): scala.Int = { /* compiled code */ } + def foo2722(): scala.Int = { /* compiled code */ } + def foo2723(): scala.Int = { /* compiled code */ } + def foo2724(): scala.Int = { /* compiled code */ } + def foo2725(): scala.Int = { /* compiled code */ } + def foo2726(): scala.Int = { /* compiled code */ } + def foo2727(): scala.Int = { /* compiled code */ } + def foo2728(): scala.Int = { /* compiled code */ } + def foo2729(): scala.Int = { /* compiled code */ } + def foo2730(): scala.Int = { /* compiled code */ } + def foo2731(): scala.Int = { /* compiled code */ } + def foo2732(): scala.Int = { /* compiled code */ } + def foo2733(): scala.Int = { /* compiled code */ } + def foo2734(): scala.Int = { /* compiled code */ } + def foo2735(): scala.Int = { /* compiled code */ } + def foo2736(): scala.Int = { /* compiled code */ } + def foo2737(): scala.Int = { /* compiled code */ } + def foo2738(): scala.Int = { /* compiled code */ } + def foo2739(): scala.Int = { /* compiled code */ } + def foo2740(): scala.Int = { /* compiled code */ } + def foo2741(): scala.Int = { /* compiled code */ } + def foo2742(): scala.Int = { /* compiled code */ } + def foo2743(): scala.Int = { /* compiled code */ } + def foo2744(): scala.Int = { /* compiled code */ } + def foo2745(): scala.Int = { /* compiled code */ } + def foo2746(): scala.Int = { /* compiled code */ } + def foo2747(): scala.Int = { /* compiled code */ } + def foo2748(): scala.Int = { /* compiled code */ } + def foo2749(): scala.Int = { /* compiled code */ } + def foo2750(): scala.Int = { /* compiled code */ } + def foo2751(): scala.Int = { /* compiled code */ } + def foo2752(): scala.Int = { /* compiled code */ } + def foo2753(): scala.Int = { /* compiled code */ } + def foo2754(): scala.Int = { /* compiled code */ } + def foo2755(): scala.Int = { /* compiled code */ } + def foo2756(): scala.Int = { /* compiled code */ } + def foo2757(): scala.Int = { /* compiled code */ } + def foo2758(): scala.Int = { /* compiled code */ } + def foo2759(): scala.Int = { /* compiled code */ } + def foo2760(): scala.Int = { /* compiled code */ } + def foo2761(): scala.Int = { /* compiled code */ } + def foo2762(): scala.Int = { /* compiled code */ } + def foo2763(): scala.Int = { /* compiled code */ } + def foo2764(): scala.Int = { /* compiled code */ } + def foo2765(): scala.Int = { /* compiled code */ } + def foo2766(): scala.Int = { /* compiled code */ } + def foo2767(): scala.Int = { /* compiled code */ } + def foo2768(): scala.Int = { /* compiled code */ } + def foo2769(): scala.Int = { /* compiled code */ } + def foo2770(): scala.Int = { /* compiled code */ } + def foo2771(): scala.Int = { /* compiled code */ } + def foo2772(): scala.Int = { /* compiled code */ } + def foo2773(): scala.Int = { /* compiled code */ } + def foo2774(): scala.Int = { /* compiled code */ } + def foo2775(): scala.Int = { /* compiled code */ } + def foo2776(): scala.Int = { /* compiled code */ } + def foo2777(): scala.Int = { /* compiled code */ } + def foo2778(): scala.Int = { /* compiled code */ } + def foo2779(): scala.Int = { /* compiled code */ } + def foo2780(): scala.Int = { /* compiled code */ } + def foo2781(): scala.Int = { /* compiled code */ } + def foo2782(): scala.Int = { /* compiled code */ } + def foo2783(): scala.Int = { /* compiled code */ } + def foo2784(): scala.Int = { /* compiled code */ } + def foo2785(): scala.Int = { /* compiled code */ } + def foo2786(): scala.Int = { /* compiled code */ } + def foo2787(): scala.Int = { /* compiled code */ } + def foo2788(): scala.Int = { /* compiled code */ } + def foo2789(): scala.Int = { /* compiled code */ } + def foo2790(): scala.Int = { /* compiled code */ } + def foo2791(): scala.Int = { /* compiled code */ } + def foo2792(): scala.Int = { /* compiled code */ } + def foo2793(): scala.Int = { /* compiled code */ } + def foo2794(): scala.Int = { /* compiled code */ } + def foo2795(): scala.Int = { /* compiled code */ } + def foo2796(): scala.Int = { /* compiled code */ } + def foo2797(): scala.Int = { /* compiled code */ } + def foo2798(): scala.Int = { /* compiled code */ } + def foo2799(): scala.Int = { /* compiled code */ } + def foo2800(): scala.Int = { /* compiled code */ } + def foo2801(): scala.Int = { /* compiled code */ } + def foo2802(): scala.Int = { /* compiled code */ } + def foo2803(): scala.Int = { /* compiled code */ } + def foo2804(): scala.Int = { /* compiled code */ } + def foo2805(): scala.Int = { /* compiled code */ } + def foo2806(): scala.Int = { /* compiled code */ } + def foo2807(): scala.Int = { /* compiled code */ } + def foo2808(): scala.Int = { /* compiled code */ } + def foo2809(): scala.Int = { /* compiled code */ } + def foo2810(): scala.Int = { /* compiled code */ } + def foo2811(): scala.Int = { /* compiled code */ } + def foo2812(): scala.Int = { /* compiled code */ } + def foo2813(): scala.Int = { /* compiled code */ } + def foo2814(): scala.Int = { /* compiled code */ } + def foo2815(): scala.Int = { /* compiled code */ } + def foo2816(): scala.Int = { /* compiled code */ } + def foo2817(): scala.Int = { /* compiled code */ } + def foo2818(): scala.Int = { /* compiled code */ } + def foo2819(): scala.Int = { /* compiled code */ } + def foo2820(): scala.Int = { /* compiled code */ } + def foo2821(): scala.Int = { /* compiled code */ } + def foo2822(): scala.Int = { /* compiled code */ } + def foo2823(): scala.Int = { /* compiled code */ } + def foo2824(): scala.Int = { /* compiled code */ } + def foo2825(): scala.Int = { /* compiled code */ } + def foo2826(): scala.Int = { /* compiled code */ } + def foo2827(): scala.Int = { /* compiled code */ } + def foo2828(): scala.Int = { /* compiled code */ } + def foo2829(): scala.Int = { /* compiled code */ } + def foo2830(): scala.Int = { /* compiled code */ } + def foo2831(): scala.Int = { /* compiled code */ } + def foo2832(): scala.Int = { /* compiled code */ } + def foo2833(): scala.Int = { /* compiled code */ } + def foo2834(): scala.Int = { /* compiled code */ } + def foo2835(): scala.Int = { /* compiled code */ } + def foo2836(): scala.Int = { /* compiled code */ } + def foo2837(): scala.Int = { /* compiled code */ } + def foo2838(): scala.Int = { /* compiled code */ } + def foo2839(): scala.Int = { /* compiled code */ } + def foo2840(): scala.Int = { /* compiled code */ } + def foo2841(): scala.Int = { /* compiled code */ } + def foo2842(): scala.Int = { /* compiled code */ } + def foo2843(): scala.Int = { /* compiled code */ } + def foo2844(): scala.Int = { /* compiled code */ } + def foo2845(): scala.Int = { /* compiled code */ } + def foo2846(): scala.Int = { /* compiled code */ } + def foo2847(): scala.Int = { /* compiled code */ } + def foo2848(): scala.Int = { /* compiled code */ } + def foo2849(): scala.Int = { /* compiled code */ } + def foo2850(): scala.Int = { /* compiled code */ } + def foo2851(): scala.Int = { /* compiled code */ } + def foo2852(): scala.Int = { /* compiled code */ } + def foo2853(): scala.Int = { /* compiled code */ } + def foo2854(): scala.Int = { /* compiled code */ } + def foo2855(): scala.Int = { /* compiled code */ } + def foo2856(): scala.Int = { /* compiled code */ } + def foo2857(): scala.Int = { /* compiled code */ } + def foo2858(): scala.Int = { /* compiled code */ } + def foo2859(): scala.Int = { /* compiled code */ } + def foo2860(): scala.Int = { /* compiled code */ } + def foo2861(): scala.Int = { /* compiled code */ } + def foo2862(): scala.Int = { /* compiled code */ } + def foo2863(): scala.Int = { /* compiled code */ } + def foo2864(): scala.Int = { /* compiled code */ } + def foo2865(): scala.Int = { /* compiled code */ } + def foo2866(): scala.Int = { /* compiled code */ } + def foo2867(): scala.Int = { /* compiled code */ } + def foo2868(): scala.Int = { /* compiled code */ } + def foo2869(): scala.Int = { /* compiled code */ } + def foo2870(): scala.Int = { /* compiled code */ } + def foo2871(): scala.Int = { /* compiled code */ } + def foo2872(): scala.Int = { /* compiled code */ } + def foo2873(): scala.Int = { /* compiled code */ } + def foo2874(): scala.Int = { /* compiled code */ } + def foo2875(): scala.Int = { /* compiled code */ } + def foo2876(): scala.Int = { /* compiled code */ } + def foo2877(): scala.Int = { /* compiled code */ } + def foo2878(): scala.Int = { /* compiled code */ } + def foo2879(): scala.Int = { /* compiled code */ } + def foo2880(): scala.Int = { /* compiled code */ } + def foo2881(): scala.Int = { /* compiled code */ } + def foo2882(): scala.Int = { /* compiled code */ } + def foo2883(): scala.Int = { /* compiled code */ } + def foo2884(): scala.Int = { /* compiled code */ } + def foo2885(): scala.Int = { /* compiled code */ } + def foo2886(): scala.Int = { /* compiled code */ } + def foo2887(): scala.Int = { /* compiled code */ } + def foo2888(): scala.Int = { /* compiled code */ } + def foo2889(): scala.Int = { /* compiled code */ } + def foo2890(): scala.Int = { /* compiled code */ } + def foo2891(): scala.Int = { /* compiled code */ } + def foo2892(): scala.Int = { /* compiled code */ } + def foo2893(): scala.Int = { /* compiled code */ } + def foo2894(): scala.Int = { /* compiled code */ } + def foo2895(): scala.Int = { /* compiled code */ } + def foo2896(): scala.Int = { /* compiled code */ } + def foo2897(): scala.Int = { /* compiled code */ } + def foo2898(): scala.Int = { /* compiled code */ } + def foo2899(): scala.Int = { /* compiled code */ } + def foo2900(): scala.Int = { /* compiled code */ } + def foo2901(): scala.Int = { /* compiled code */ } + def foo2902(): scala.Int = { /* compiled code */ } + def foo2903(): scala.Int = { /* compiled code */ } + def foo2904(): scala.Int = { /* compiled code */ } + def foo2905(): scala.Int = { /* compiled code */ } + def foo2906(): scala.Int = { /* compiled code */ } + def foo2907(): scala.Int = { /* compiled code */ } + def foo2908(): scala.Int = { /* compiled code */ } + def foo2909(): scala.Int = { /* compiled code */ } + def foo2910(): scala.Int = { /* compiled code */ } + def foo2911(): scala.Int = { /* compiled code */ } + def foo2912(): scala.Int = { /* compiled code */ } + def foo2913(): scala.Int = { /* compiled code */ } + def foo2914(): scala.Int = { /* compiled code */ } + def foo2915(): scala.Int = { /* compiled code */ } + def foo2916(): scala.Int = { /* compiled code */ } + def foo2917(): scala.Int = { /* compiled code */ } + def foo2918(): scala.Int = { /* compiled code */ } + def foo2919(): scala.Int = { /* compiled code */ } + def foo2920(): scala.Int = { /* compiled code */ } + def foo2921(): scala.Int = { /* compiled code */ } + def foo2922(): scala.Int = { /* compiled code */ } + def foo2923(): scala.Int = { /* compiled code */ } + def foo2924(): scala.Int = { /* compiled code */ } + def foo2925(): scala.Int = { /* compiled code */ } + def foo2926(): scala.Int = { /* compiled code */ } + def foo2927(): scala.Int = { /* compiled code */ } + def foo2928(): scala.Int = { /* compiled code */ } + def foo2929(): scala.Int = { /* compiled code */ } + def foo2930(): scala.Int = { /* compiled code */ } + def foo2931(): scala.Int = { /* compiled code */ } + def foo2932(): scala.Int = { /* compiled code */ } + def foo2933(): scala.Int = { /* compiled code */ } + def foo2934(): scala.Int = { /* compiled code */ } + def foo2935(): scala.Int = { /* compiled code */ } + def foo2936(): scala.Int = { /* compiled code */ } + def foo2937(): scala.Int = { /* compiled code */ } + def foo2938(): scala.Int = { /* compiled code */ } + def foo2939(): scala.Int = { /* compiled code */ } + def foo2940(): scala.Int = { /* compiled code */ } + def foo2941(): scala.Int = { /* compiled code */ } + def foo2942(): scala.Int = { /* compiled code */ } + def foo2943(): scala.Int = { /* compiled code */ } + def foo2944(): scala.Int = { /* compiled code */ } + def foo2945(): scala.Int = { /* compiled code */ } + def foo2946(): scala.Int = { /* compiled code */ } + def foo2947(): scala.Int = { /* compiled code */ } + def foo2948(): scala.Int = { /* compiled code */ } + def foo2949(): scala.Int = { /* compiled code */ } + def foo2950(): scala.Int = { /* compiled code */ } + def foo2951(): scala.Int = { /* compiled code */ } + def foo2952(): scala.Int = { /* compiled code */ } + def foo2953(): scala.Int = { /* compiled code */ } + def foo2954(): scala.Int = { /* compiled code */ } + def foo2955(): scala.Int = { /* compiled code */ } + def foo2956(): scala.Int = { /* compiled code */ } + def foo2957(): scala.Int = { /* compiled code */ } + def foo2958(): scala.Int = { /* compiled code */ } + def foo2959(): scala.Int = { /* compiled code */ } + def foo2960(): scala.Int = { /* compiled code */ } + def foo2961(): scala.Int = { /* compiled code */ } + def foo2962(): scala.Int = { /* compiled code */ } + def foo2963(): scala.Int = { /* compiled code */ } + def foo2964(): scala.Int = { /* compiled code */ } + def foo2965(): scala.Int = { /* compiled code */ } + def foo2966(): scala.Int = { /* compiled code */ } + def foo2967(): scala.Int = { /* compiled code */ } + def foo2968(): scala.Int = { /* compiled code */ } + def foo2969(): scala.Int = { /* compiled code */ } + def foo2970(): scala.Int = { /* compiled code */ } + def foo2971(): scala.Int = { /* compiled code */ } + def foo2972(): scala.Int = { /* compiled code */ } + def foo2973(): scala.Int = { /* compiled code */ } + def foo2974(): scala.Int = { /* compiled code */ } + def foo2975(): scala.Int = { /* compiled code */ } + def foo2976(): scala.Int = { /* compiled code */ } + def foo2977(): scala.Int = { /* compiled code */ } + def foo2978(): scala.Int = { /* compiled code */ } + def foo2979(): scala.Int = { /* compiled code */ } + def foo2980(): scala.Int = { /* compiled code */ } + def foo2981(): scala.Int = { /* compiled code */ } + def foo2982(): scala.Int = { /* compiled code */ } + def foo2983(): scala.Int = { /* compiled code */ } + def foo2984(): scala.Int = { /* compiled code */ } + def foo2985(): scala.Int = { /* compiled code */ } + def foo2986(): scala.Int = { /* compiled code */ } + def foo2987(): scala.Int = { /* compiled code */ } + def foo2988(): scala.Int = { /* compiled code */ } + def foo2989(): scala.Int = { /* compiled code */ } + def foo2990(): scala.Int = { /* compiled code */ } + def foo2991(): scala.Int = { /* compiled code */ } + def foo2992(): scala.Int = { /* compiled code */ } + def foo2993(): scala.Int = { /* compiled code */ } + def foo2994(): scala.Int = { /* compiled code */ } + def foo2995(): scala.Int = { /* compiled code */ } + def foo2996(): scala.Int = { /* compiled code */ } + def foo2997(): scala.Int = { /* compiled code */ } + def foo2998(): scala.Int = { /* compiled code */ } + def foo2999(): scala.Int = { /* compiled code */ } + def foo3000(): scala.Int = { /* compiled code */ } + def foo3001(): scala.Int = { /* compiled code */ } + def foo3002(): scala.Int = { /* compiled code */ } + def foo3003(): scala.Int = { /* compiled code */ } + def foo3004(): scala.Int = { /* compiled code */ } + def foo3005(): scala.Int = { /* compiled code */ } + def foo3006(): scala.Int = { /* compiled code */ } + def foo3007(): scala.Int = { /* compiled code */ } + def foo3008(): scala.Int = { /* compiled code */ } + def foo3009(): scala.Int = { /* compiled code */ } + def foo3010(): scala.Int = { /* compiled code */ } + def foo3011(): scala.Int = { /* compiled code */ } + def foo3012(): scala.Int = { /* compiled code */ } + def foo3013(): scala.Int = { /* compiled code */ } + def foo3014(): scala.Int = { /* compiled code */ } + def foo3015(): scala.Int = { /* compiled code */ } + def foo3016(): scala.Int = { /* compiled code */ } + def foo3017(): scala.Int = { /* compiled code */ } + def foo3018(): scala.Int = { /* compiled code */ } + def foo3019(): scala.Int = { /* compiled code */ } + def foo3020(): scala.Int = { /* compiled code */ } + def foo3021(): scala.Int = { /* compiled code */ } + def foo3022(): scala.Int = { /* compiled code */ } + def foo3023(): scala.Int = { /* compiled code */ } + def foo3024(): scala.Int = { /* compiled code */ } + def foo3025(): scala.Int = { /* compiled code */ } + def foo3026(): scala.Int = { /* compiled code */ } + def foo3027(): scala.Int = { /* compiled code */ } + def foo3028(): scala.Int = { /* compiled code */ } + def foo3029(): scala.Int = { /* compiled code */ } + def foo3030(): scala.Int = { /* compiled code */ } + def foo3031(): scala.Int = { /* compiled code */ } + def foo3032(): scala.Int = { /* compiled code */ } + def foo3033(): scala.Int = { /* compiled code */ } + def foo3034(): scala.Int = { /* compiled code */ } + def foo3035(): scala.Int = { /* compiled code */ } + def foo3036(): scala.Int = { /* compiled code */ } + def foo3037(): scala.Int = { /* compiled code */ } + def foo3038(): scala.Int = { /* compiled code */ } + def foo3039(): scala.Int = { /* compiled code */ } + def foo3040(): scala.Int = { /* compiled code */ } + def foo3041(): scala.Int = { /* compiled code */ } + def foo3042(): scala.Int = { /* compiled code */ } + def foo3043(): scala.Int = { /* compiled code */ } + def foo3044(): scala.Int = { /* compiled code */ } + def foo3045(): scala.Int = { /* compiled code */ } + def foo3046(): scala.Int = { /* compiled code */ } + def foo3047(): scala.Int = { /* compiled code */ } + def foo3048(): scala.Int = { /* compiled code */ } + def foo3049(): scala.Int = { /* compiled code */ } + def foo3050(): scala.Int = { /* compiled code */ } + def foo3051(): scala.Int = { /* compiled code */ } + def foo3052(): scala.Int = { /* compiled code */ } + def foo3053(): scala.Int = { /* compiled code */ } + def foo3054(): scala.Int = { /* compiled code */ } + def foo3055(): scala.Int = { /* compiled code */ } + def foo3056(): scala.Int = { /* compiled code */ } + def foo3057(): scala.Int = { /* compiled code */ } + def foo3058(): scala.Int = { /* compiled code */ } + def foo3059(): scala.Int = { /* compiled code */ } + def foo3060(): scala.Int = { /* compiled code */ } + def foo3061(): scala.Int = { /* compiled code */ } + def foo3062(): scala.Int = { /* compiled code */ } + def foo3063(): scala.Int = { /* compiled code */ } + def foo3064(): scala.Int = { /* compiled code */ } + def foo3065(): scala.Int = { /* compiled code */ } + def foo3066(): scala.Int = { /* compiled code */ } + def foo3067(): scala.Int = { /* compiled code */ } + def foo3068(): scala.Int = { /* compiled code */ } + def foo3069(): scala.Int = { /* compiled code */ } + def foo3070(): scala.Int = { /* compiled code */ } + def foo3071(): scala.Int = { /* compiled code */ } + def foo3072(): scala.Int = { /* compiled code */ } + def foo3073(): scala.Int = { /* compiled code */ } + def foo3074(): scala.Int = { /* compiled code */ } + def foo3075(): scala.Int = { /* compiled code */ } + def foo3076(): scala.Int = { /* compiled code */ } + def foo3077(): scala.Int = { /* compiled code */ } + def foo3078(): scala.Int = { /* compiled code */ } + def foo3079(): scala.Int = { /* compiled code */ } + def foo3080(): scala.Int = { /* compiled code */ } + def foo3081(): scala.Int = { /* compiled code */ } + def foo3082(): scala.Int = { /* compiled code */ } + def foo3083(): scala.Int = { /* compiled code */ } + def foo3084(): scala.Int = { /* compiled code */ } + def foo3085(): scala.Int = { /* compiled code */ } + def foo3086(): scala.Int = { /* compiled code */ } + def foo3087(): scala.Int = { /* compiled code */ } + def foo3088(): scala.Int = { /* compiled code */ } + def foo3089(): scala.Int = { /* compiled code */ } + def foo3090(): scala.Int = { /* compiled code */ } + def foo3091(): scala.Int = { /* compiled code */ } + def foo3092(): scala.Int = { /* compiled code */ } + def foo3093(): scala.Int = { /* compiled code */ } + def foo3094(): scala.Int = { /* compiled code */ } + def foo3095(): scala.Int = { /* compiled code */ } + def foo3096(): scala.Int = { /* compiled code */ } + def foo3097(): scala.Int = { /* compiled code */ } + def foo3098(): scala.Int = { /* compiled code */ } + def foo3099(): scala.Int = { /* compiled code */ } + def foo3100(): scala.Int = { /* compiled code */ } + def foo3101(): scala.Int = { /* compiled code */ } + def foo3102(): scala.Int = { /* compiled code */ } + def foo3103(): scala.Int = { /* compiled code */ } + def foo3104(): scala.Int = { /* compiled code */ } + def foo3105(): scala.Int = { /* compiled code */ } + def foo3106(): scala.Int = { /* compiled code */ } + def foo3107(): scala.Int = { /* compiled code */ } + def foo3108(): scala.Int = { /* compiled code */ } + def foo3109(): scala.Int = { /* compiled code */ } + def foo3110(): scala.Int = { /* compiled code */ } + def foo3111(): scala.Int = { /* compiled code */ } + def foo3112(): scala.Int = { /* compiled code */ } + def foo3113(): scala.Int = { /* compiled code */ } + def foo3114(): scala.Int = { /* compiled code */ } + def foo3115(): scala.Int = { /* compiled code */ } + def foo3116(): scala.Int = { /* compiled code */ } + def foo3117(): scala.Int = { /* compiled code */ } + def foo3118(): scala.Int = { /* compiled code */ } + def foo3119(): scala.Int = { /* compiled code */ } + def foo3120(): scala.Int = { /* compiled code */ } + def foo3121(): scala.Int = { /* compiled code */ } + def foo3122(): scala.Int = { /* compiled code */ } + def foo3123(): scala.Int = { /* compiled code */ } + def foo3124(): scala.Int = { /* compiled code */ } + def foo3125(): scala.Int = { /* compiled code */ } + def foo3126(): scala.Int = { /* compiled code */ } + def foo3127(): scala.Int = { /* compiled code */ } + def foo3128(): scala.Int = { /* compiled code */ } + def foo3129(): scala.Int = { /* compiled code */ } + def foo3130(): scala.Int = { /* compiled code */ } + def foo3131(): scala.Int = { /* compiled code */ } + def foo3132(): scala.Int = { /* compiled code */ } + def foo3133(): scala.Int = { /* compiled code */ } + def foo3134(): scala.Int = { /* compiled code */ } + def foo3135(): scala.Int = { /* compiled code */ } + def foo3136(): scala.Int = { /* compiled code */ } + def foo3137(): scala.Int = { /* compiled code */ } + def foo3138(): scala.Int = { /* compiled code */ } + def foo3139(): scala.Int = { /* compiled code */ } + def foo3140(): scala.Int = { /* compiled code */ } + def foo3141(): scala.Int = { /* compiled code */ } + def foo3142(): scala.Int = { /* compiled code */ } + def foo3143(): scala.Int = { /* compiled code */ } + def foo3144(): scala.Int = { /* compiled code */ } + def foo3145(): scala.Int = { /* compiled code */ } + def foo3146(): scala.Int = { /* compiled code */ } + def foo3147(): scala.Int = { /* compiled code */ } + def foo3148(): scala.Int = { /* compiled code */ } + def foo3149(): scala.Int = { /* compiled code */ } + def foo3150(): scala.Int = { /* compiled code */ } + def foo3151(): scala.Int = { /* compiled code */ } + def foo3152(): scala.Int = { /* compiled code */ } + def foo3153(): scala.Int = { /* compiled code */ } + def foo3154(): scala.Int = { /* compiled code */ } + def foo3155(): scala.Int = { /* compiled code */ } + def foo3156(): scala.Int = { /* compiled code */ } + def foo3157(): scala.Int = { /* compiled code */ } + def foo3158(): scala.Int = { /* compiled code */ } + def foo3159(): scala.Int = { /* compiled code */ } + def foo3160(): scala.Int = { /* compiled code */ } + def foo3161(): scala.Int = { /* compiled code */ } + def foo3162(): scala.Int = { /* compiled code */ } + def foo3163(): scala.Int = { /* compiled code */ } + def foo3164(): scala.Int = { /* compiled code */ } + def foo3165(): scala.Int = { /* compiled code */ } + def foo3166(): scala.Int = { /* compiled code */ } + def foo3167(): scala.Int = { /* compiled code */ } + def foo3168(): scala.Int = { /* compiled code */ } + def foo3169(): scala.Int = { /* compiled code */ } + def foo3170(): scala.Int = { /* compiled code */ } + def foo3171(): scala.Int = { /* compiled code */ } + def foo3172(): scala.Int = { /* compiled code */ } + def foo3173(): scala.Int = { /* compiled code */ } + def foo3174(): scala.Int = { /* compiled code */ } + def foo3175(): scala.Int = { /* compiled code */ } + def foo3176(): scala.Int = { /* compiled code */ } + def foo3177(): scala.Int = { /* compiled code */ } + def foo3178(): scala.Int = { /* compiled code */ } + def foo3179(): scala.Int = { /* compiled code */ } + def foo3180(): scala.Int = { /* compiled code */ } + def foo3181(): scala.Int = { /* compiled code */ } + def foo3182(): scala.Int = { /* compiled code */ } + def foo3183(): scala.Int = { /* compiled code */ } + def foo3184(): scala.Int = { /* compiled code */ } + def foo3185(): scala.Int = { /* compiled code */ } + def foo3186(): scala.Int = { /* compiled code */ } + def foo3187(): scala.Int = { /* compiled code */ } + def foo3188(): scala.Int = { /* compiled code */ } + def foo3189(): scala.Int = { /* compiled code */ } + def foo3190(): scala.Int = { /* compiled code */ } + def foo3191(): scala.Int = { /* compiled code */ } + def foo3192(): scala.Int = { /* compiled code */ } + def foo3193(): scala.Int = { /* compiled code */ } + def foo3194(): scala.Int = { /* compiled code */ } + def foo3195(): scala.Int = { /* compiled code */ } + def foo3196(): scala.Int = { /* compiled code */ } + def foo3197(): scala.Int = { /* compiled code */ } + def foo3198(): scala.Int = { /* compiled code */ } + def foo3199(): scala.Int = { /* compiled code */ } + def foo3200(): scala.Int = { /* compiled code */ } + def foo3201(): scala.Int = { /* compiled code */ } + def foo3202(): scala.Int = { /* compiled code */ } + def foo3203(): scala.Int = { /* compiled code */ } + def foo3204(): scala.Int = { /* compiled code */ } + def foo3205(): scala.Int = { /* compiled code */ } + def foo3206(): scala.Int = { /* compiled code */ } + def foo3207(): scala.Int = { /* compiled code */ } + def foo3208(): scala.Int = { /* compiled code */ } + def foo3209(): scala.Int = { /* compiled code */ } + def foo3210(): scala.Int = { /* compiled code */ } + def foo3211(): scala.Int = { /* compiled code */ } + def foo3212(): scala.Int = { /* compiled code */ } + def foo3213(): scala.Int = { /* compiled code */ } + def foo3214(): scala.Int = { /* compiled code */ } + def foo3215(): scala.Int = { /* compiled code */ } + def foo3216(): scala.Int = { /* compiled code */ } + def foo3217(): scala.Int = { /* compiled code */ } + def foo3218(): scala.Int = { /* compiled code */ } + def foo3219(): scala.Int = { /* compiled code */ } + def foo3220(): scala.Int = { /* compiled code */ } + def foo3221(): scala.Int = { /* compiled code */ } + def foo3222(): scala.Int = { /* compiled code */ } + def foo3223(): scala.Int = { /* compiled code */ } + def foo3224(): scala.Int = { /* compiled code */ } + def foo3225(): scala.Int = { /* compiled code */ } + def foo3226(): scala.Int = { /* compiled code */ } + def foo3227(): scala.Int = { /* compiled code */ } + def foo3228(): scala.Int = { /* compiled code */ } + def foo3229(): scala.Int = { /* compiled code */ } + def foo3230(): scala.Int = { /* compiled code */ } + def foo3231(): scala.Int = { /* compiled code */ } + def foo3232(): scala.Int = { /* compiled code */ } + def foo3233(): scala.Int = { /* compiled code */ } + def foo3234(): scala.Int = { /* compiled code */ } + def foo3235(): scala.Int = { /* compiled code */ } + def foo3236(): scala.Int = { /* compiled code */ } + def foo3237(): scala.Int = { /* compiled code */ } + def foo3238(): scala.Int = { /* compiled code */ } + def foo3239(): scala.Int = { /* compiled code */ } + def foo3240(): scala.Int = { /* compiled code */ } + def foo3241(): scala.Int = { /* compiled code */ } + def foo3242(): scala.Int = { /* compiled code */ } + def foo3243(): scala.Int = { /* compiled code */ } + def foo3244(): scala.Int = { /* compiled code */ } + def foo3245(): scala.Int = { /* compiled code */ } + def foo3246(): scala.Int = { /* compiled code */ } + def foo3247(): scala.Int = { /* compiled code */ } + def foo3248(): scala.Int = { /* compiled code */ } + def foo3249(): scala.Int = { /* compiled code */ } + def foo3250(): scala.Int = { /* compiled code */ } + def foo3251(): scala.Int = { /* compiled code */ } + def foo3252(): scala.Int = { /* compiled code */ } + def foo3253(): scala.Int = { /* compiled code */ } + def foo3254(): scala.Int = { /* compiled code */ } + def foo3255(): scala.Int = { /* compiled code */ } + def foo3256(): scala.Int = { /* compiled code */ } + def foo3257(): scala.Int = { /* compiled code */ } + def foo3258(): scala.Int = { /* compiled code */ } + def foo3259(): scala.Int = { /* compiled code */ } + def foo3260(): scala.Int = { /* compiled code */ } + def foo3261(): scala.Int = { /* compiled code */ } + def foo3262(): scala.Int = { /* compiled code */ } + def foo3263(): scala.Int = { /* compiled code */ } + def foo3264(): scala.Int = { /* compiled code */ } + def foo3265(): scala.Int = { /* compiled code */ } + def foo3266(): scala.Int = { /* compiled code */ } + def foo3267(): scala.Int = { /* compiled code */ } + def foo3268(): scala.Int = { /* compiled code */ } + def foo3269(): scala.Int = { /* compiled code */ } + def foo3270(): scala.Int = { /* compiled code */ } + def foo3271(): scala.Int = { /* compiled code */ } + def foo3272(): scala.Int = { /* compiled code */ } + def foo3273(): scala.Int = { /* compiled code */ } + def foo3274(): scala.Int = { /* compiled code */ } + def foo3275(): scala.Int = { /* compiled code */ } + def foo3276(): scala.Int = { /* compiled code */ } + def foo3277(): scala.Int = { /* compiled code */ } + def foo3278(): scala.Int = { /* compiled code */ } + def foo3279(): scala.Int = { /* compiled code */ } + def foo3280(): scala.Int = { /* compiled code */ } + def foo3281(): scala.Int = { /* compiled code */ } + def foo3282(): scala.Int = { /* compiled code */ } + def foo3283(): scala.Int = { /* compiled code */ } + def foo3284(): scala.Int = { /* compiled code */ } + def foo3285(): scala.Int = { /* compiled code */ } + def foo3286(): scala.Int = { /* compiled code */ } + def foo3287(): scala.Int = { /* compiled code */ } + def foo3288(): scala.Int = { /* compiled code */ } + def foo3289(): scala.Int = { /* compiled code */ } + def foo3290(): scala.Int = { /* compiled code */ } + def foo3291(): scala.Int = { /* compiled code */ } + def foo3292(): scala.Int = { /* compiled code */ } + def foo3293(): scala.Int = { /* compiled code */ } + def foo3294(): scala.Int = { /* compiled code */ } + def foo3295(): scala.Int = { /* compiled code */ } + def foo3296(): scala.Int = { /* compiled code */ } + def foo3297(): scala.Int = { /* compiled code */ } + def foo3298(): scala.Int = { /* compiled code */ } + def foo3299(): scala.Int = { /* compiled code */ } + def foo3300(): scala.Int = { /* compiled code */ } + def foo3301(): scala.Int = { /* compiled code */ } + def foo3302(): scala.Int = { /* compiled code */ } + def foo3303(): scala.Int = { /* compiled code */ } + def foo3304(): scala.Int = { /* compiled code */ } + def foo3305(): scala.Int = { /* compiled code */ } + def foo3306(): scala.Int = { /* compiled code */ } + def foo3307(): scala.Int = { /* compiled code */ } + def foo3308(): scala.Int = { /* compiled code */ } + def foo3309(): scala.Int = { /* compiled code */ } + def foo3310(): scala.Int = { /* compiled code */ } + def foo3311(): scala.Int = { /* compiled code */ } + def foo3312(): scala.Int = { /* compiled code */ } + def foo3313(): scala.Int = { /* compiled code */ } + def foo3314(): scala.Int = { /* compiled code */ } + def foo3315(): scala.Int = { /* compiled code */ } + def foo3316(): scala.Int = { /* compiled code */ } + def foo3317(): scala.Int = { /* compiled code */ } + def foo3318(): scala.Int = { /* compiled code */ } + def foo3319(): scala.Int = { /* compiled code */ } + def foo3320(): scala.Int = { /* compiled code */ } + def foo3321(): scala.Int = { /* compiled code */ } + def foo3322(): scala.Int = { /* compiled code */ } + def foo3323(): scala.Int = { /* compiled code */ } + def foo3324(): scala.Int = { /* compiled code */ } + def foo3325(): scala.Int = { /* compiled code */ } + def foo3326(): scala.Int = { /* compiled code */ } + def foo3327(): scala.Int = { /* compiled code */ } + def foo3328(): scala.Int = { /* compiled code */ } + def foo3329(): scala.Int = { /* compiled code */ } + def foo3330(): scala.Int = { /* compiled code */ } + def foo3331(): scala.Int = { /* compiled code */ } + def foo3332(): scala.Int = { /* compiled code */ } + def foo3333(): scala.Int = { /* compiled code */ } + def foo3334(): scala.Int = { /* compiled code */ } + def foo3335(): scala.Int = { /* compiled code */ } + def foo3336(): scala.Int = { /* compiled code */ } + def foo3337(): scala.Int = { /* compiled code */ } + def foo3338(): scala.Int = { /* compiled code */ } + def foo3339(): scala.Int = { /* compiled code */ } + def foo3340(): scala.Int = { /* compiled code */ } + def foo3341(): scala.Int = { /* compiled code */ } + def foo3342(): scala.Int = { /* compiled code */ } + def foo3343(): scala.Int = { /* compiled code */ } + def foo3344(): scala.Int = { /* compiled code */ } + def foo3345(): scala.Int = { /* compiled code */ } + def foo3346(): scala.Int = { /* compiled code */ } + def foo3347(): scala.Int = { /* compiled code */ } + def foo3348(): scala.Int = { /* compiled code */ } + def foo3349(): scala.Int = { /* compiled code */ } + def foo3350(): scala.Int = { /* compiled code */ } + def foo3351(): scala.Int = { /* compiled code */ } + def foo3352(): scala.Int = { /* compiled code */ } + def foo3353(): scala.Int = { /* compiled code */ } + def foo3354(): scala.Int = { /* compiled code */ } + def foo3355(): scala.Int = { /* compiled code */ } + def foo3356(): scala.Int = { /* compiled code */ } + def foo3357(): scala.Int = { /* compiled code */ } + def foo3358(): scala.Int = { /* compiled code */ } + def foo3359(): scala.Int = { /* compiled code */ } + def foo3360(): scala.Int = { /* compiled code */ } + def foo3361(): scala.Int = { /* compiled code */ } + def foo3362(): scala.Int = { /* compiled code */ } + def foo3363(): scala.Int = { /* compiled code */ } + def foo3364(): scala.Int = { /* compiled code */ } + def foo3365(): scala.Int = { /* compiled code */ } + def foo3366(): scala.Int = { /* compiled code */ } + def foo3367(): scala.Int = { /* compiled code */ } + def foo3368(): scala.Int = { /* compiled code */ } + def foo3369(): scala.Int = { /* compiled code */ } + def foo3370(): scala.Int = { /* compiled code */ } + def foo3371(): scala.Int = { /* compiled code */ } + def foo3372(): scala.Int = { /* compiled code */ } + def foo3373(): scala.Int = { /* compiled code */ } + def foo3374(): scala.Int = { /* compiled code */ } + def foo3375(): scala.Int = { /* compiled code */ } + def foo3376(): scala.Int = { /* compiled code */ } + def foo3377(): scala.Int = { /* compiled code */ } + def foo3378(): scala.Int = { /* compiled code */ } + def foo3379(): scala.Int = { /* compiled code */ } + def foo3380(): scala.Int = { /* compiled code */ } + def foo3381(): scala.Int = { /* compiled code */ } + def foo3382(): scala.Int = { /* compiled code */ } + def foo3383(): scala.Int = { /* compiled code */ } + def foo3384(): scala.Int = { /* compiled code */ } + def foo3385(): scala.Int = { /* compiled code */ } + def foo3386(): scala.Int = { /* compiled code */ } + def foo3387(): scala.Int = { /* compiled code */ } + def foo3388(): scala.Int = { /* compiled code */ } + def foo3389(): scala.Int = { /* compiled code */ } + def foo3390(): scala.Int = { /* compiled code */ } + def foo3391(): scala.Int = { /* compiled code */ } + def foo3392(): scala.Int = { /* compiled code */ } + def foo3393(): scala.Int = { /* compiled code */ } + def foo3394(): scala.Int = { /* compiled code */ } + def foo3395(): scala.Int = { /* compiled code */ } + def foo3396(): scala.Int = { /* compiled code */ } + def foo3397(): scala.Int = { /* compiled code */ } + def foo3398(): scala.Int = { /* compiled code */ } + def foo3399(): scala.Int = { /* compiled code */ } + def foo3400(): scala.Int = { /* compiled code */ } + def foo3401(): scala.Int = { /* compiled code */ } + def foo3402(): scala.Int = { /* compiled code */ } + def foo3403(): scala.Int = { /* compiled code */ } + def foo3404(): scala.Int = { /* compiled code */ } + def foo3405(): scala.Int = { /* compiled code */ } + def foo3406(): scala.Int = { /* compiled code */ } + def foo3407(): scala.Int = { /* compiled code */ } + def foo3408(): scala.Int = { /* compiled code */ } + def foo3409(): scala.Int = { /* compiled code */ } + def foo3410(): scala.Int = { /* compiled code */ } + def foo3411(): scala.Int = { /* compiled code */ } + def foo3412(): scala.Int = { /* compiled code */ } + def foo3413(): scala.Int = { /* compiled code */ } + def foo3414(): scala.Int = { /* compiled code */ } + def foo3415(): scala.Int = { /* compiled code */ } + def foo3416(): scala.Int = { /* compiled code */ } + def foo3417(): scala.Int = { /* compiled code */ } + def foo3418(): scala.Int = { /* compiled code */ } + def foo3419(): scala.Int = { /* compiled code */ } + def foo3420(): scala.Int = { /* compiled code */ } + def foo3421(): scala.Int = { /* compiled code */ } + def foo3422(): scala.Int = { /* compiled code */ } + def foo3423(): scala.Int = { /* compiled code */ } + def foo3424(): scala.Int = { /* compiled code */ } + def foo3425(): scala.Int = { /* compiled code */ } + def foo3426(): scala.Int = { /* compiled code */ } + def foo3427(): scala.Int = { /* compiled code */ } + def foo3428(): scala.Int = { /* compiled code */ } + def foo3429(): scala.Int = { /* compiled code */ } + def foo3430(): scala.Int = { /* compiled code */ } + def foo3431(): scala.Int = { /* compiled code */ } + def foo3432(): scala.Int = { /* compiled code */ } + def foo3433(): scala.Int = { /* compiled code */ } + def foo3434(): scala.Int = { /* compiled code */ } + def foo3435(): scala.Int = { /* compiled code */ } + def foo3436(): scala.Int = { /* compiled code */ } + def foo3437(): scala.Int = { /* compiled code */ } + def foo3438(): scala.Int = { /* compiled code */ } + def foo3439(): scala.Int = { /* compiled code */ } + def foo3440(): scala.Int = { /* compiled code */ } + def foo3441(): scala.Int = { /* compiled code */ } + def foo3442(): scala.Int = { /* compiled code */ } + def foo3443(): scala.Int = { /* compiled code */ } + def foo3444(): scala.Int = { /* compiled code */ } + def foo3445(): scala.Int = { /* compiled code */ } + def foo3446(): scala.Int = { /* compiled code */ } + def foo3447(): scala.Int = { /* compiled code */ } + def foo3448(): scala.Int = { /* compiled code */ } + def foo3449(): scala.Int = { /* compiled code */ } + def foo3450(): scala.Int = { /* compiled code */ } + def foo3451(): scala.Int = { /* compiled code */ } + def foo3452(): scala.Int = { /* compiled code */ } + def foo3453(): scala.Int = { /* compiled code */ } + def foo3454(): scala.Int = { /* compiled code */ } + def foo3455(): scala.Int = { /* compiled code */ } + def foo3456(): scala.Int = { /* compiled code */ } + def foo3457(): scala.Int = { /* compiled code */ } + def foo3458(): scala.Int = { /* compiled code */ } + def foo3459(): scala.Int = { /* compiled code */ } + def foo3460(): scala.Int = { /* compiled code */ } + def foo3461(): scala.Int = { /* compiled code */ } + def foo3462(): scala.Int = { /* compiled code */ } + def foo3463(): scala.Int = { /* compiled code */ } + def foo3464(): scala.Int = { /* compiled code */ } + def foo3465(): scala.Int = { /* compiled code */ } + def foo3466(): scala.Int = { /* compiled code */ } + def foo3467(): scala.Int = { /* compiled code */ } + def foo3468(): scala.Int = { /* compiled code */ } + def foo3469(): scala.Int = { /* compiled code */ } + def foo3470(): scala.Int = { /* compiled code */ } + def foo3471(): scala.Int = { /* compiled code */ } + def foo3472(): scala.Int = { /* compiled code */ } + def foo3473(): scala.Int = { /* compiled code */ } + def foo3474(): scala.Int = { /* compiled code */ } + def foo3475(): scala.Int = { /* compiled code */ } + def foo3476(): scala.Int = { /* compiled code */ } + def foo3477(): scala.Int = { /* compiled code */ } + def foo3478(): scala.Int = { /* compiled code */ } + def foo3479(): scala.Int = { /* compiled code */ } + def foo3480(): scala.Int = { /* compiled code */ } + def foo3481(): scala.Int = { /* compiled code */ } + def foo3482(): scala.Int = { /* compiled code */ } + def foo3483(): scala.Int = { /* compiled code */ } + def foo3484(): scala.Int = { /* compiled code */ } + def foo3485(): scala.Int = { /* compiled code */ } + def foo3486(): scala.Int = { /* compiled code */ } + def foo3487(): scala.Int = { /* compiled code */ } + def foo3488(): scala.Int = { /* compiled code */ } + def foo3489(): scala.Int = { /* compiled code */ } + def foo3490(): scala.Int = { /* compiled code */ } + def foo3491(): scala.Int = { /* compiled code */ } + def foo3492(): scala.Int = { /* compiled code */ } + def foo3493(): scala.Int = { /* compiled code */ } + def foo3494(): scala.Int = { /* compiled code */ } + def foo3495(): scala.Int = { /* compiled code */ } + def foo3496(): scala.Int = { /* compiled code */ } + def foo3497(): scala.Int = { /* compiled code */ } + def foo3498(): scala.Int = { /* compiled code */ } + def foo3499(): scala.Int = { /* compiled code */ } + def foo3500(): scala.Int = { /* compiled code */ } +} diff --git a/test/files/scalap/t8679.scala b/test/files/scalap/t8679.scala new file mode 100644 index 0000000000..f008a7af35 --- /dev/null +++ b/test/files/scalap/t8679.scala @@ -0,0 +1,3502 @@ +class T8679 { + def foo1(): Int = 3 + def foo2(): Int = 4 + def foo3(): Int = 5 + def foo4(): Int = 6 + def foo5(): Int = 7 + def foo6(): Int = 8 + def foo7(): Int = 9 + def foo8(): Int = 10 + def foo9(): Int = 11 + def foo10(): Int = 12 + def foo11(): Int = 13 + def foo12(): Int = 14 + def foo13(): Int = 15 + def foo14(): Int = 16 + def foo15(): Int = 17 + def foo16(): Int = 18 + def foo17(): Int = 19 + def foo18(): Int = 20 + def foo19(): Int = 21 + def foo20(): Int = 22 + def foo21(): Int = 23 + def foo22(): Int = 24 + def foo23(): Int = 25 + def foo24(): Int = 26 + def foo25(): Int = 27 + def foo26(): Int = 28 + def foo27(): Int = 29 + def foo28(): Int = 30 + def foo29(): Int = 31 + def foo30(): Int = 32 + def foo31(): Int = 33 + def foo32(): Int = 34 + def foo33(): Int = 35 + def foo34(): Int = 36 + def foo35(): Int = 37 + def foo36(): Int = 38 + def foo37(): Int = 39 + def foo38(): Int = 40 + def foo39(): Int = 41 + def foo40(): Int = 42 + def foo41(): Int = 43 + def foo42(): Int = 44 + def foo43(): Int = 45 + def foo44(): Int = 46 + def foo45(): Int = 47 + def foo46(): Int = 48 + def foo47(): Int = 49 + def foo48(): Int = 50 + def foo49(): Int = 51 + def foo50(): Int = 52 + def foo51(): Int = 53 + def foo52(): Int = 54 + def foo53(): Int = 55 + def foo54(): Int = 56 + def foo55(): Int = 57 + def foo56(): Int = 58 + def foo57(): Int = 59 + def foo58(): Int = 60 + def foo59(): Int = 61 + def foo60(): Int = 62 + def foo61(): Int = 63 + def foo62(): Int = 64 + def foo63(): Int = 65 + def foo64(): Int = 66 + def foo65(): Int = 67 + def foo66(): Int = 68 + def foo67(): Int = 69 + def foo68(): Int = 70 + def foo69(): Int = 71 + def foo70(): Int = 72 + def foo71(): Int = 73 + def foo72(): Int = 74 + def foo73(): Int = 75 + def foo74(): Int = 76 + def foo75(): Int = 77 + def foo76(): Int = 78 + def foo77(): Int = 79 + def foo78(): Int = 80 + def foo79(): Int = 81 + def foo80(): Int = 82 + def foo81(): Int = 83 + def foo82(): Int = 84 + def foo83(): Int = 85 + def foo84(): Int = 86 + def foo85(): Int = 87 + def foo86(): Int = 88 + def foo87(): Int = 89 + def foo88(): Int = 90 + def foo89(): Int = 91 + def foo90(): Int = 92 + def foo91(): Int = 93 + def foo92(): Int = 94 + def foo93(): Int = 95 + def foo94(): Int = 96 + def foo95(): Int = 97 + def foo96(): Int = 98 + def foo97(): Int = 99 + def foo98(): Int = 100 + def foo99(): Int = 101 + def foo100(): Int = 102 + def foo101(): Int = 103 + def foo102(): Int = 104 + def foo103(): Int = 105 + def foo104(): Int = 106 + def foo105(): Int = 107 + def foo106(): Int = 108 + def foo107(): Int = 109 + def foo108(): Int = 110 + def foo109(): Int = 111 + def foo110(): Int = 112 + def foo111(): Int = 113 + def foo112(): Int = 114 + def foo113(): Int = 115 + def foo114(): Int = 116 + def foo115(): Int = 117 + def foo116(): Int = 118 + def foo117(): Int = 119 + def foo118(): Int = 120 + def foo119(): Int = 121 + def foo120(): Int = 122 + def foo121(): Int = 123 + def foo122(): Int = 124 + def foo123(): Int = 125 + def foo124(): Int = 126 + def foo125(): Int = 127 + def foo126(): Int = 128 + def foo127(): Int = 129 + def foo128(): Int = 130 + def foo129(): Int = 131 + def foo130(): Int = 132 + def foo131(): Int = 133 + def foo132(): Int = 134 + def foo133(): Int = 135 + def foo134(): Int = 136 + def foo135(): Int = 137 + def foo136(): Int = 138 + def foo137(): Int = 139 + def foo138(): Int = 140 + def foo139(): Int = 141 + def foo140(): Int = 142 + def foo141(): Int = 143 + def foo142(): Int = 144 + def foo143(): Int = 145 + def foo144(): Int = 146 + def foo145(): Int = 147 + def foo146(): Int = 148 + def foo147(): Int = 149 + def foo148(): Int = 150 + def foo149(): Int = 151 + def foo150(): Int = 152 + def foo151(): Int = 153 + def foo152(): Int = 154 + def foo153(): Int = 155 + def foo154(): Int = 156 + def foo155(): Int = 157 + def foo156(): Int = 158 + def foo157(): Int = 159 + def foo158(): Int = 160 + def foo159(): Int = 161 + def foo160(): Int = 162 + def foo161(): Int = 163 + def foo162(): Int = 164 + def foo163(): Int = 165 + def foo164(): Int = 166 + def foo165(): Int = 167 + def foo166(): Int = 168 + def foo167(): Int = 169 + def foo168(): Int = 170 + def foo169(): Int = 171 + def foo170(): Int = 172 + def foo171(): Int = 173 + def foo172(): Int = 174 + def foo173(): Int = 175 + def foo174(): Int = 176 + def foo175(): Int = 177 + def foo176(): Int = 178 + def foo177(): Int = 179 + def foo178(): Int = 180 + def foo179(): Int = 181 + def foo180(): Int = 182 + def foo181(): Int = 183 + def foo182(): Int = 184 + def foo183(): Int = 185 + def foo184(): Int = 186 + def foo185(): Int = 187 + def foo186(): Int = 188 + def foo187(): Int = 189 + def foo188(): Int = 190 + def foo189(): Int = 191 + def foo190(): Int = 192 + def foo191(): Int = 193 + def foo192(): Int = 194 + def foo193(): Int = 195 + def foo194(): Int = 196 + def foo195(): Int = 197 + def foo196(): Int = 198 + def foo197(): Int = 199 + def foo198(): Int = 200 + def foo199(): Int = 201 + def foo200(): Int = 202 + def foo201(): Int = 203 + def foo202(): Int = 204 + def foo203(): Int = 205 + def foo204(): Int = 206 + def foo205(): Int = 207 + def foo206(): Int = 208 + def foo207(): Int = 209 + def foo208(): Int = 210 + def foo209(): Int = 211 + def foo210(): Int = 212 + def foo211(): Int = 213 + def foo212(): Int = 214 + def foo213(): Int = 215 + def foo214(): Int = 216 + def foo215(): Int = 217 + def foo216(): Int = 218 + def foo217(): Int = 219 + def foo218(): Int = 220 + def foo219(): Int = 221 + def foo220(): Int = 222 + def foo221(): Int = 223 + def foo222(): Int = 224 + def foo223(): Int = 225 + def foo224(): Int = 226 + def foo225(): Int = 227 + def foo226(): Int = 228 + def foo227(): Int = 229 + def foo228(): Int = 230 + def foo229(): Int = 231 + def foo230(): Int = 232 + def foo231(): Int = 233 + def foo232(): Int = 234 + def foo233(): Int = 235 + def foo234(): Int = 236 + def foo235(): Int = 237 + def foo236(): Int = 238 + def foo237(): Int = 239 + def foo238(): Int = 240 + def foo239(): Int = 241 + def foo240(): Int = 242 + def foo241(): Int = 243 + def foo242(): Int = 244 + def foo243(): Int = 245 + def foo244(): Int = 246 + def foo245(): Int = 247 + def foo246(): Int = 248 + def foo247(): Int = 249 + def foo248(): Int = 250 + def foo249(): Int = 251 + def foo250(): Int = 252 + def foo251(): Int = 253 + def foo252(): Int = 254 + def foo253(): Int = 255 + def foo254(): Int = 256 + def foo255(): Int = 257 + def foo256(): Int = 258 + def foo257(): Int = 259 + def foo258(): Int = 260 + def foo259(): Int = 261 + def foo260(): Int = 262 + def foo261(): Int = 263 + def foo262(): Int = 264 + def foo263(): Int = 265 + def foo264(): Int = 266 + def foo265(): Int = 267 + def foo266(): Int = 268 + def foo267(): Int = 269 + def foo268(): Int = 270 + def foo269(): Int = 271 + def foo270(): Int = 272 + def foo271(): Int = 273 + def foo272(): Int = 274 + def foo273(): Int = 275 + def foo274(): Int = 276 + def foo275(): Int = 277 + def foo276(): Int = 278 + def foo277(): Int = 279 + def foo278(): Int = 280 + def foo279(): Int = 281 + def foo280(): Int = 282 + def foo281(): Int = 283 + def foo282(): Int = 284 + def foo283(): Int = 285 + def foo284(): Int = 286 + def foo285(): Int = 287 + def foo286(): Int = 288 + def foo287(): Int = 289 + def foo288(): Int = 290 + def foo289(): Int = 291 + def foo290(): Int = 292 + def foo291(): Int = 293 + def foo292(): Int = 294 + def foo293(): Int = 295 + def foo294(): Int = 296 + def foo295(): Int = 297 + def foo296(): Int = 298 + def foo297(): Int = 299 + def foo298(): Int = 300 + def foo299(): Int = 301 + def foo300(): Int = 302 + def foo301(): Int = 303 + def foo302(): Int = 304 + def foo303(): Int = 305 + def foo304(): Int = 306 + def foo305(): Int = 307 + def foo306(): Int = 308 + def foo307(): Int = 309 + def foo308(): Int = 310 + def foo309(): Int = 311 + def foo310(): Int = 312 + def foo311(): Int = 313 + def foo312(): Int = 314 + def foo313(): Int = 315 + def foo314(): Int = 316 + def foo315(): Int = 317 + def foo316(): Int = 318 + def foo317(): Int = 319 + def foo318(): Int = 320 + def foo319(): Int = 321 + def foo320(): Int = 322 + def foo321(): Int = 323 + def foo322(): Int = 324 + def foo323(): Int = 325 + def foo324(): Int = 326 + def foo325(): Int = 327 + def foo326(): Int = 328 + def foo327(): Int = 329 + def foo328(): Int = 330 + def foo329(): Int = 331 + def foo330(): Int = 332 + def foo331(): Int = 333 + def foo332(): Int = 334 + def foo333(): Int = 335 + def foo334(): Int = 336 + def foo335(): Int = 337 + def foo336(): Int = 338 + def foo337(): Int = 339 + def foo338(): Int = 340 + def foo339(): Int = 341 + def foo340(): Int = 342 + def foo341(): Int = 343 + def foo342(): Int = 344 + def foo343(): Int = 345 + def foo344(): Int = 346 + def foo345(): Int = 347 + def foo346(): Int = 348 + def foo347(): Int = 349 + def foo348(): Int = 350 + def foo349(): Int = 351 + def foo350(): Int = 352 + def foo351(): Int = 353 + def foo352(): Int = 354 + def foo353(): Int = 355 + def foo354(): Int = 356 + def foo355(): Int = 357 + def foo356(): Int = 358 + def foo357(): Int = 359 + def foo358(): Int = 360 + def foo359(): Int = 361 + def foo360(): Int = 362 + def foo361(): Int = 363 + def foo362(): Int = 364 + def foo363(): Int = 365 + def foo364(): Int = 366 + def foo365(): Int = 367 + def foo366(): Int = 368 + def foo367(): Int = 369 + def foo368(): Int = 370 + def foo369(): Int = 371 + def foo370(): Int = 372 + def foo371(): Int = 373 + def foo372(): Int = 374 + def foo373(): Int = 375 + def foo374(): Int = 376 + def foo375(): Int = 377 + def foo376(): Int = 378 + def foo377(): Int = 379 + def foo378(): Int = 380 + def foo379(): Int = 381 + def foo380(): Int = 382 + def foo381(): Int = 383 + def foo382(): Int = 384 + def foo383(): Int = 385 + def foo384(): Int = 386 + def foo385(): Int = 387 + def foo386(): Int = 388 + def foo387(): Int = 389 + def foo388(): Int = 390 + def foo389(): Int = 391 + def foo390(): Int = 392 + def foo391(): Int = 393 + def foo392(): Int = 394 + def foo393(): Int = 395 + def foo394(): Int = 396 + def foo395(): Int = 397 + def foo396(): Int = 398 + def foo397(): Int = 399 + def foo398(): Int = 400 + def foo399(): Int = 401 + def foo400(): Int = 402 + def foo401(): Int = 403 + def foo402(): Int = 404 + def foo403(): Int = 405 + def foo404(): Int = 406 + def foo405(): Int = 407 + def foo406(): Int = 408 + def foo407(): Int = 409 + def foo408(): Int = 410 + def foo409(): Int = 411 + def foo410(): Int = 412 + def foo411(): Int = 413 + def foo412(): Int = 414 + def foo413(): Int = 415 + def foo414(): Int = 416 + def foo415(): Int = 417 + def foo416(): Int = 418 + def foo417(): Int = 419 + def foo418(): Int = 420 + def foo419(): Int = 421 + def foo420(): Int = 422 + def foo421(): Int = 423 + def foo422(): Int = 424 + def foo423(): Int = 425 + def foo424(): Int = 426 + def foo425(): Int = 427 + def foo426(): Int = 428 + def foo427(): Int = 429 + def foo428(): Int = 430 + def foo429(): Int = 431 + def foo430(): Int = 432 + def foo431(): Int = 433 + def foo432(): Int = 434 + def foo433(): Int = 435 + def foo434(): Int = 436 + def foo435(): Int = 437 + def foo436(): Int = 438 + def foo437(): Int = 439 + def foo438(): Int = 440 + def foo439(): Int = 441 + def foo440(): Int = 442 + def foo441(): Int = 443 + def foo442(): Int = 444 + def foo443(): Int = 445 + def foo444(): Int = 446 + def foo445(): Int = 447 + def foo446(): Int = 448 + def foo447(): Int = 449 + def foo448(): Int = 450 + def foo449(): Int = 451 + def foo450(): Int = 452 + def foo451(): Int = 453 + def foo452(): Int = 454 + def foo453(): Int = 455 + def foo454(): Int = 456 + def foo455(): Int = 457 + def foo456(): Int = 458 + def foo457(): Int = 459 + def foo458(): Int = 460 + def foo459(): Int = 461 + def foo460(): Int = 462 + def foo461(): Int = 463 + def foo462(): Int = 464 + def foo463(): Int = 465 + def foo464(): Int = 466 + def foo465(): Int = 467 + def foo466(): Int = 468 + def foo467(): Int = 469 + def foo468(): Int = 470 + def foo469(): Int = 471 + def foo470(): Int = 472 + def foo471(): Int = 473 + def foo472(): Int = 474 + def foo473(): Int = 475 + def foo474(): Int = 476 + def foo475(): Int = 477 + def foo476(): Int = 478 + def foo477(): Int = 479 + def foo478(): Int = 480 + def foo479(): Int = 481 + def foo480(): Int = 482 + def foo481(): Int = 483 + def foo482(): Int = 484 + def foo483(): Int = 485 + def foo484(): Int = 486 + def foo485(): Int = 487 + def foo486(): Int = 488 + def foo487(): Int = 489 + def foo488(): Int = 490 + def foo489(): Int = 491 + def foo490(): Int = 492 + def foo491(): Int = 493 + def foo492(): Int = 494 + def foo493(): Int = 495 + def foo494(): Int = 496 + def foo495(): Int = 497 + def foo496(): Int = 498 + def foo497(): Int = 499 + def foo498(): Int = 500 + def foo499(): Int = 501 + def foo500(): Int = 502 + def foo501(): Int = 503 + def foo502(): Int = 504 + def foo503(): Int = 505 + def foo504(): Int = 506 + def foo505(): Int = 507 + def foo506(): Int = 508 + def foo507(): Int = 509 + def foo508(): Int = 510 + def foo509(): Int = 511 + def foo510(): Int = 512 + def foo511(): Int = 513 + def foo512(): Int = 514 + def foo513(): Int = 515 + def foo514(): Int = 516 + def foo515(): Int = 517 + def foo516(): Int = 518 + def foo517(): Int = 519 + def foo518(): Int = 520 + def foo519(): Int = 521 + def foo520(): Int = 522 + def foo521(): Int = 523 + def foo522(): Int = 524 + def foo523(): Int = 525 + def foo524(): Int = 526 + def foo525(): Int = 527 + def foo526(): Int = 528 + def foo527(): Int = 529 + def foo528(): Int = 530 + def foo529(): Int = 531 + def foo530(): Int = 532 + def foo531(): Int = 533 + def foo532(): Int = 534 + def foo533(): Int = 535 + def foo534(): Int = 536 + def foo535(): Int = 537 + def foo536(): Int = 538 + def foo537(): Int = 539 + def foo538(): Int = 540 + def foo539(): Int = 541 + def foo540(): Int = 542 + def foo541(): Int = 543 + def foo542(): Int = 544 + def foo543(): Int = 545 + def foo544(): Int = 546 + def foo545(): Int = 547 + def foo546(): Int = 548 + def foo547(): Int = 549 + def foo548(): Int = 550 + def foo549(): Int = 551 + def foo550(): Int = 552 + def foo551(): Int = 553 + def foo552(): Int = 554 + def foo553(): Int = 555 + def foo554(): Int = 556 + def foo555(): Int = 557 + def foo556(): Int = 558 + def foo557(): Int = 559 + def foo558(): Int = 560 + def foo559(): Int = 561 + def foo560(): Int = 562 + def foo561(): Int = 563 + def foo562(): Int = 564 + def foo563(): Int = 565 + def foo564(): Int = 566 + def foo565(): Int = 567 + def foo566(): Int = 568 + def foo567(): Int = 569 + def foo568(): Int = 570 + def foo569(): Int = 571 + def foo570(): Int = 572 + def foo571(): Int = 573 + def foo572(): Int = 574 + def foo573(): Int = 575 + def foo574(): Int = 576 + def foo575(): Int = 577 + def foo576(): Int = 578 + def foo577(): Int = 579 + def foo578(): Int = 580 + def foo579(): Int = 581 + def foo580(): Int = 582 + def foo581(): Int = 583 + def foo582(): Int = 584 + def foo583(): Int = 585 + def foo584(): Int = 586 + def foo585(): Int = 587 + def foo586(): Int = 588 + def foo587(): Int = 589 + def foo588(): Int = 590 + def foo589(): Int = 591 + def foo590(): Int = 592 + def foo591(): Int = 593 + def foo592(): Int = 594 + def foo593(): Int = 595 + def foo594(): Int = 596 + def foo595(): Int = 597 + def foo596(): Int = 598 + def foo597(): Int = 599 + def foo598(): Int = 600 + def foo599(): Int = 601 + def foo600(): Int = 602 + def foo601(): Int = 603 + def foo602(): Int = 604 + def foo603(): Int = 605 + def foo604(): Int = 606 + def foo605(): Int = 607 + def foo606(): Int = 608 + def foo607(): Int = 609 + def foo608(): Int = 610 + def foo609(): Int = 611 + def foo610(): Int = 612 + def foo611(): Int = 613 + def foo612(): Int = 614 + def foo613(): Int = 615 + def foo614(): Int = 616 + def foo615(): Int = 617 + def foo616(): Int = 618 + def foo617(): Int = 619 + def foo618(): Int = 620 + def foo619(): Int = 621 + def foo620(): Int = 622 + def foo621(): Int = 623 + def foo622(): Int = 624 + def foo623(): Int = 625 + def foo624(): Int = 626 + def foo625(): Int = 627 + def foo626(): Int = 628 + def foo627(): Int = 629 + def foo628(): Int = 630 + def foo629(): Int = 631 + def foo630(): Int = 632 + def foo631(): Int = 633 + def foo632(): Int = 634 + def foo633(): Int = 635 + def foo634(): Int = 636 + def foo635(): Int = 637 + def foo636(): Int = 638 + def foo637(): Int = 639 + def foo638(): Int = 640 + def foo639(): Int = 641 + def foo640(): Int = 642 + def foo641(): Int = 643 + def foo642(): Int = 644 + def foo643(): Int = 645 + def foo644(): Int = 646 + def foo645(): Int = 647 + def foo646(): Int = 648 + def foo647(): Int = 649 + def foo648(): Int = 650 + def foo649(): Int = 651 + def foo650(): Int = 652 + def foo651(): Int = 653 + def foo652(): Int = 654 + def foo653(): Int = 655 + def foo654(): Int = 656 + def foo655(): Int = 657 + def foo656(): Int = 658 + def foo657(): Int = 659 + def foo658(): Int = 660 + def foo659(): Int = 661 + def foo660(): Int = 662 + def foo661(): Int = 663 + def foo662(): Int = 664 + def foo663(): Int = 665 + def foo664(): Int = 666 + def foo665(): Int = 667 + def foo666(): Int = 668 + def foo667(): Int = 669 + def foo668(): Int = 670 + def foo669(): Int = 671 + def foo670(): Int = 672 + def foo671(): Int = 673 + def foo672(): Int = 674 + def foo673(): Int = 675 + def foo674(): Int = 676 + def foo675(): Int = 677 + def foo676(): Int = 678 + def foo677(): Int = 679 + def foo678(): Int = 680 + def foo679(): Int = 681 + def foo680(): Int = 682 + def foo681(): Int = 683 + def foo682(): Int = 684 + def foo683(): Int = 685 + def foo684(): Int = 686 + def foo685(): Int = 687 + def foo686(): Int = 688 + def foo687(): Int = 689 + def foo688(): Int = 690 + def foo689(): Int = 691 + def foo690(): Int = 692 + def foo691(): Int = 693 + def foo692(): Int = 694 + def foo693(): Int = 695 + def foo694(): Int = 696 + def foo695(): Int = 697 + def foo696(): Int = 698 + def foo697(): Int = 699 + def foo698(): Int = 700 + def foo699(): Int = 701 + def foo700(): Int = 702 + def foo701(): Int = 703 + def foo702(): Int = 704 + def foo703(): Int = 705 + def foo704(): Int = 706 + def foo705(): Int = 707 + def foo706(): Int = 708 + def foo707(): Int = 709 + def foo708(): Int = 710 + def foo709(): Int = 711 + def foo710(): Int = 712 + def foo711(): Int = 713 + def foo712(): Int = 714 + def foo713(): Int = 715 + def foo714(): Int = 716 + def foo715(): Int = 717 + def foo716(): Int = 718 + def foo717(): Int = 719 + def foo718(): Int = 720 + def foo719(): Int = 721 + def foo720(): Int = 722 + def foo721(): Int = 723 + def foo722(): Int = 724 + def foo723(): Int = 725 + def foo724(): Int = 726 + def foo725(): Int = 727 + def foo726(): Int = 728 + def foo727(): Int = 729 + def foo728(): Int = 730 + def foo729(): Int = 731 + def foo730(): Int = 732 + def foo731(): Int = 733 + def foo732(): Int = 734 + def foo733(): Int = 735 + def foo734(): Int = 736 + def foo735(): Int = 737 + def foo736(): Int = 738 + def foo737(): Int = 739 + def foo738(): Int = 740 + def foo739(): Int = 741 + def foo740(): Int = 742 + def foo741(): Int = 743 + def foo742(): Int = 744 + def foo743(): Int = 745 + def foo744(): Int = 746 + def foo745(): Int = 747 + def foo746(): Int = 748 + def foo747(): Int = 749 + def foo748(): Int = 750 + def foo749(): Int = 751 + def foo750(): Int = 752 + def foo751(): Int = 753 + def foo752(): Int = 754 + def foo753(): Int = 755 + def foo754(): Int = 756 + def foo755(): Int = 757 + def foo756(): Int = 758 + def foo757(): Int = 759 + def foo758(): Int = 760 + def foo759(): Int = 761 + def foo760(): Int = 762 + def foo761(): Int = 763 + def foo762(): Int = 764 + def foo763(): Int = 765 + def foo764(): Int = 766 + def foo765(): Int = 767 + def foo766(): Int = 768 + def foo767(): Int = 769 + def foo768(): Int = 770 + def foo769(): Int = 771 + def foo770(): Int = 772 + def foo771(): Int = 773 + def foo772(): Int = 774 + def foo773(): Int = 775 + def foo774(): Int = 776 + def foo775(): Int = 777 + def foo776(): Int = 778 + def foo777(): Int = 779 + def foo778(): Int = 780 + def foo779(): Int = 781 + def foo780(): Int = 782 + def foo781(): Int = 783 + def foo782(): Int = 784 + def foo783(): Int = 785 + def foo784(): Int = 786 + def foo785(): Int = 787 + def foo786(): Int = 788 + def foo787(): Int = 789 + def foo788(): Int = 790 + def foo789(): Int = 791 + def foo790(): Int = 792 + def foo791(): Int = 793 + def foo792(): Int = 794 + def foo793(): Int = 795 + def foo794(): Int = 796 + def foo795(): Int = 797 + def foo796(): Int = 798 + def foo797(): Int = 799 + def foo798(): Int = 800 + def foo799(): Int = 801 + def foo800(): Int = 802 + def foo801(): Int = 803 + def foo802(): Int = 804 + def foo803(): Int = 805 + def foo804(): Int = 806 + def foo805(): Int = 807 + def foo806(): Int = 808 + def foo807(): Int = 809 + def foo808(): Int = 810 + def foo809(): Int = 811 + def foo810(): Int = 812 + def foo811(): Int = 813 + def foo812(): Int = 814 + def foo813(): Int = 815 + def foo814(): Int = 816 + def foo815(): Int = 817 + def foo816(): Int = 818 + def foo817(): Int = 819 + def foo818(): Int = 820 + def foo819(): Int = 821 + def foo820(): Int = 822 + def foo821(): Int = 823 + def foo822(): Int = 824 + def foo823(): Int = 825 + def foo824(): Int = 826 + def foo825(): Int = 827 + def foo826(): Int = 828 + def foo827(): Int = 829 + def foo828(): Int = 830 + def foo829(): Int = 831 + def foo830(): Int = 832 + def foo831(): Int = 833 + def foo832(): Int = 834 + def foo833(): Int = 835 + def foo834(): Int = 836 + def foo835(): Int = 837 + def foo836(): Int = 838 + def foo837(): Int = 839 + def foo838(): Int = 840 + def foo839(): Int = 841 + def foo840(): Int = 842 + def foo841(): Int = 843 + def foo842(): Int = 844 + def foo843(): Int = 845 + def foo844(): Int = 846 + def foo845(): Int = 847 + def foo846(): Int = 848 + def foo847(): Int = 849 + def foo848(): Int = 850 + def foo849(): Int = 851 + def foo850(): Int = 852 + def foo851(): Int = 853 + def foo852(): Int = 854 + def foo853(): Int = 855 + def foo854(): Int = 856 + def foo855(): Int = 857 + def foo856(): Int = 858 + def foo857(): Int = 859 + def foo858(): Int = 860 + def foo859(): Int = 861 + def foo860(): Int = 862 + def foo861(): Int = 863 + def foo862(): Int = 864 + def foo863(): Int = 865 + def foo864(): Int = 866 + def foo865(): Int = 867 + def foo866(): Int = 868 + def foo867(): Int = 869 + def foo868(): Int = 870 + def foo869(): Int = 871 + def foo870(): Int = 872 + def foo871(): Int = 873 + def foo872(): Int = 874 + def foo873(): Int = 875 + def foo874(): Int = 876 + def foo875(): Int = 877 + def foo876(): Int = 878 + def foo877(): Int = 879 + def foo878(): Int = 880 + def foo879(): Int = 881 + def foo880(): Int = 882 + def foo881(): Int = 883 + def foo882(): Int = 884 + def foo883(): Int = 885 + def foo884(): Int = 886 + def foo885(): Int = 887 + def foo886(): Int = 888 + def foo887(): Int = 889 + def foo888(): Int = 890 + def foo889(): Int = 891 + def foo890(): Int = 892 + def foo891(): Int = 893 + def foo892(): Int = 894 + def foo893(): Int = 895 + def foo894(): Int = 896 + def foo895(): Int = 897 + def foo896(): Int = 898 + def foo897(): Int = 899 + def foo898(): Int = 900 + def foo899(): Int = 901 + def foo900(): Int = 902 + def foo901(): Int = 903 + def foo902(): Int = 904 + def foo903(): Int = 905 + def foo904(): Int = 906 + def foo905(): Int = 907 + def foo906(): Int = 908 + def foo907(): Int = 909 + def foo908(): Int = 910 + def foo909(): Int = 911 + def foo910(): Int = 912 + def foo911(): Int = 913 + def foo912(): Int = 914 + def foo913(): Int = 915 + def foo914(): Int = 916 + def foo915(): Int = 917 + def foo916(): Int = 918 + def foo917(): Int = 919 + def foo918(): Int = 920 + def foo919(): Int = 921 + def foo920(): Int = 922 + def foo921(): Int = 923 + def foo922(): Int = 924 + def foo923(): Int = 925 + def foo924(): Int = 926 + def foo925(): Int = 927 + def foo926(): Int = 928 + def foo927(): Int = 929 + def foo928(): Int = 930 + def foo929(): Int = 931 + def foo930(): Int = 932 + def foo931(): Int = 933 + def foo932(): Int = 934 + def foo933(): Int = 935 + def foo934(): Int = 936 + def foo935(): Int = 937 + def foo936(): Int = 938 + def foo937(): Int = 939 + def foo938(): Int = 940 + def foo939(): Int = 941 + def foo940(): Int = 942 + def foo941(): Int = 943 + def foo942(): Int = 944 + def foo943(): Int = 945 + def foo944(): Int = 946 + def foo945(): Int = 947 + def foo946(): Int = 948 + def foo947(): Int = 949 + def foo948(): Int = 950 + def foo949(): Int = 951 + def foo950(): Int = 952 + def foo951(): Int = 953 + def foo952(): Int = 954 + def foo953(): Int = 955 + def foo954(): Int = 956 + def foo955(): Int = 957 + def foo956(): Int = 958 + def foo957(): Int = 959 + def foo958(): Int = 960 + def foo959(): Int = 961 + def foo960(): Int = 962 + def foo961(): Int = 963 + def foo962(): Int = 964 + def foo963(): Int = 965 + def foo964(): Int = 966 + def foo965(): Int = 967 + def foo966(): Int = 968 + def foo967(): Int = 969 + def foo968(): Int = 970 + def foo969(): Int = 971 + def foo970(): Int = 972 + def foo971(): Int = 973 + def foo972(): Int = 974 + def foo973(): Int = 975 + def foo974(): Int = 976 + def foo975(): Int = 977 + def foo976(): Int = 978 + def foo977(): Int = 979 + def foo978(): Int = 980 + def foo979(): Int = 981 + def foo980(): Int = 982 + def foo981(): Int = 983 + def foo982(): Int = 984 + def foo983(): Int = 985 + def foo984(): Int = 986 + def foo985(): Int = 987 + def foo986(): Int = 988 + def foo987(): Int = 989 + def foo988(): Int = 990 + def foo989(): Int = 991 + def foo990(): Int = 992 + def foo991(): Int = 993 + def foo992(): Int = 994 + def foo993(): Int = 995 + def foo994(): Int = 996 + def foo995(): Int = 997 + def foo996(): Int = 998 + def foo997(): Int = 999 + def foo998(): Int = 1000 + def foo999(): Int = 1001 + def foo1000(): Int = 1002 + def foo1001(): Int = 1003 + def foo1002(): Int = 1004 + def foo1003(): Int = 1005 + def foo1004(): Int = 1006 + def foo1005(): Int = 1007 + def foo1006(): Int = 1008 + def foo1007(): Int = 1009 + def foo1008(): Int = 1010 + def foo1009(): Int = 1011 + def foo1010(): Int = 1012 + def foo1011(): Int = 1013 + def foo1012(): Int = 1014 + def foo1013(): Int = 1015 + def foo1014(): Int = 1016 + def foo1015(): Int = 1017 + def foo1016(): Int = 1018 + def foo1017(): Int = 1019 + def foo1018(): Int = 1020 + def foo1019(): Int = 1021 + def foo1020(): Int = 1022 + def foo1021(): Int = 1023 + def foo1022(): Int = 1024 + def foo1023(): Int = 1025 + def foo1024(): Int = 1026 + def foo1025(): Int = 1027 + def foo1026(): Int = 1028 + def foo1027(): Int = 1029 + def foo1028(): Int = 1030 + def foo1029(): Int = 1031 + def foo1030(): Int = 1032 + def foo1031(): Int = 1033 + def foo1032(): Int = 1034 + def foo1033(): Int = 1035 + def foo1034(): Int = 1036 + def foo1035(): Int = 1037 + def foo1036(): Int = 1038 + def foo1037(): Int = 1039 + def foo1038(): Int = 1040 + def foo1039(): Int = 1041 + def foo1040(): Int = 1042 + def foo1041(): Int = 1043 + def foo1042(): Int = 1044 + def foo1043(): Int = 1045 + def foo1044(): Int = 1046 + def foo1045(): Int = 1047 + def foo1046(): Int = 1048 + def foo1047(): Int = 1049 + def foo1048(): Int = 1050 + def foo1049(): Int = 1051 + def foo1050(): Int = 1052 + def foo1051(): Int = 1053 + def foo1052(): Int = 1054 + def foo1053(): Int = 1055 + def foo1054(): Int = 1056 + def foo1055(): Int = 1057 + def foo1056(): Int = 1058 + def foo1057(): Int = 1059 + def foo1058(): Int = 1060 + def foo1059(): Int = 1061 + def foo1060(): Int = 1062 + def foo1061(): Int = 1063 + def foo1062(): Int = 1064 + def foo1063(): Int = 1065 + def foo1064(): Int = 1066 + def foo1065(): Int = 1067 + def foo1066(): Int = 1068 + def foo1067(): Int = 1069 + def foo1068(): Int = 1070 + def foo1069(): Int = 1071 + def foo1070(): Int = 1072 + def foo1071(): Int = 1073 + def foo1072(): Int = 1074 + def foo1073(): Int = 1075 + def foo1074(): Int = 1076 + def foo1075(): Int = 1077 + def foo1076(): Int = 1078 + def foo1077(): Int = 1079 + def foo1078(): Int = 1080 + def foo1079(): Int = 1081 + def foo1080(): Int = 1082 + def foo1081(): Int = 1083 + def foo1082(): Int = 1084 + def foo1083(): Int = 1085 + def foo1084(): Int = 1086 + def foo1085(): Int = 1087 + def foo1086(): Int = 1088 + def foo1087(): Int = 1089 + def foo1088(): Int = 1090 + def foo1089(): Int = 1091 + def foo1090(): Int = 1092 + def foo1091(): Int = 1093 + def foo1092(): Int = 1094 + def foo1093(): Int = 1095 + def foo1094(): Int = 1096 + def foo1095(): Int = 1097 + def foo1096(): Int = 1098 + def foo1097(): Int = 1099 + def foo1098(): Int = 1100 + def foo1099(): Int = 1101 + def foo1100(): Int = 1102 + def foo1101(): Int = 1103 + def foo1102(): Int = 1104 + def foo1103(): Int = 1105 + def foo1104(): Int = 1106 + def foo1105(): Int = 1107 + def foo1106(): Int = 1108 + def foo1107(): Int = 1109 + def foo1108(): Int = 1110 + def foo1109(): Int = 1111 + def foo1110(): Int = 1112 + def foo1111(): Int = 1113 + def foo1112(): Int = 1114 + def foo1113(): Int = 1115 + def foo1114(): Int = 1116 + def foo1115(): Int = 1117 + def foo1116(): Int = 1118 + def foo1117(): Int = 1119 + def foo1118(): Int = 1120 + def foo1119(): Int = 1121 + def foo1120(): Int = 1122 + def foo1121(): Int = 1123 + def foo1122(): Int = 1124 + def foo1123(): Int = 1125 + def foo1124(): Int = 1126 + def foo1125(): Int = 1127 + def foo1126(): Int = 1128 + def foo1127(): Int = 1129 + def foo1128(): Int = 1130 + def foo1129(): Int = 1131 + def foo1130(): Int = 1132 + def foo1131(): Int = 1133 + def foo1132(): Int = 1134 + def foo1133(): Int = 1135 + def foo1134(): Int = 1136 + def foo1135(): Int = 1137 + def foo1136(): Int = 1138 + def foo1137(): Int = 1139 + def foo1138(): Int = 1140 + def foo1139(): Int = 1141 + def foo1140(): Int = 1142 + def foo1141(): Int = 1143 + def foo1142(): Int = 1144 + def foo1143(): Int = 1145 + def foo1144(): Int = 1146 + def foo1145(): Int = 1147 + def foo1146(): Int = 1148 + def foo1147(): Int = 1149 + def foo1148(): Int = 1150 + def foo1149(): Int = 1151 + def foo1150(): Int = 1152 + def foo1151(): Int = 1153 + def foo1152(): Int = 1154 + def foo1153(): Int = 1155 + def foo1154(): Int = 1156 + def foo1155(): Int = 1157 + def foo1156(): Int = 1158 + def foo1157(): Int = 1159 + def foo1158(): Int = 1160 + def foo1159(): Int = 1161 + def foo1160(): Int = 1162 + def foo1161(): Int = 1163 + def foo1162(): Int = 1164 + def foo1163(): Int = 1165 + def foo1164(): Int = 1166 + def foo1165(): Int = 1167 + def foo1166(): Int = 1168 + def foo1167(): Int = 1169 + def foo1168(): Int = 1170 + def foo1169(): Int = 1171 + def foo1170(): Int = 1172 + def foo1171(): Int = 1173 + def foo1172(): Int = 1174 + def foo1173(): Int = 1175 + def foo1174(): Int = 1176 + def foo1175(): Int = 1177 + def foo1176(): Int = 1178 + def foo1177(): Int = 1179 + def foo1178(): Int = 1180 + def foo1179(): Int = 1181 + def foo1180(): Int = 1182 + def foo1181(): Int = 1183 + def foo1182(): Int = 1184 + def foo1183(): Int = 1185 + def foo1184(): Int = 1186 + def foo1185(): Int = 1187 + def foo1186(): Int = 1188 + def foo1187(): Int = 1189 + def foo1188(): Int = 1190 + def foo1189(): Int = 1191 + def foo1190(): Int = 1192 + def foo1191(): Int = 1193 + def foo1192(): Int = 1194 + def foo1193(): Int = 1195 + def foo1194(): Int = 1196 + def foo1195(): Int = 1197 + def foo1196(): Int = 1198 + def foo1197(): Int = 1199 + def foo1198(): Int = 1200 + def foo1199(): Int = 1201 + def foo1200(): Int = 1202 + def foo1201(): Int = 1203 + def foo1202(): Int = 1204 + def foo1203(): Int = 1205 + def foo1204(): Int = 1206 + def foo1205(): Int = 1207 + def foo1206(): Int = 1208 + def foo1207(): Int = 1209 + def foo1208(): Int = 1210 + def foo1209(): Int = 1211 + def foo1210(): Int = 1212 + def foo1211(): Int = 1213 + def foo1212(): Int = 1214 + def foo1213(): Int = 1215 + def foo1214(): Int = 1216 + def foo1215(): Int = 1217 + def foo1216(): Int = 1218 + def foo1217(): Int = 1219 + def foo1218(): Int = 1220 + def foo1219(): Int = 1221 + def foo1220(): Int = 1222 + def foo1221(): Int = 1223 + def foo1222(): Int = 1224 + def foo1223(): Int = 1225 + def foo1224(): Int = 1226 + def foo1225(): Int = 1227 + def foo1226(): Int = 1228 + def foo1227(): Int = 1229 + def foo1228(): Int = 1230 + def foo1229(): Int = 1231 + def foo1230(): Int = 1232 + def foo1231(): Int = 1233 + def foo1232(): Int = 1234 + def foo1233(): Int = 1235 + def foo1234(): Int = 1236 + def foo1235(): Int = 1237 + def foo1236(): Int = 1238 + def foo1237(): Int = 1239 + def foo1238(): Int = 1240 + def foo1239(): Int = 1241 + def foo1240(): Int = 1242 + def foo1241(): Int = 1243 + def foo1242(): Int = 1244 + def foo1243(): Int = 1245 + def foo1244(): Int = 1246 + def foo1245(): Int = 1247 + def foo1246(): Int = 1248 + def foo1247(): Int = 1249 + def foo1248(): Int = 1250 + def foo1249(): Int = 1251 + def foo1250(): Int = 1252 + def foo1251(): Int = 1253 + def foo1252(): Int = 1254 + def foo1253(): Int = 1255 + def foo1254(): Int = 1256 + def foo1255(): Int = 1257 + def foo1256(): Int = 1258 + def foo1257(): Int = 1259 + def foo1258(): Int = 1260 + def foo1259(): Int = 1261 + def foo1260(): Int = 1262 + def foo1261(): Int = 1263 + def foo1262(): Int = 1264 + def foo1263(): Int = 1265 + def foo1264(): Int = 1266 + def foo1265(): Int = 1267 + def foo1266(): Int = 1268 + def foo1267(): Int = 1269 + def foo1268(): Int = 1270 + def foo1269(): Int = 1271 + def foo1270(): Int = 1272 + def foo1271(): Int = 1273 + def foo1272(): Int = 1274 + def foo1273(): Int = 1275 + def foo1274(): Int = 1276 + def foo1275(): Int = 1277 + def foo1276(): Int = 1278 + def foo1277(): Int = 1279 + def foo1278(): Int = 1280 + def foo1279(): Int = 1281 + def foo1280(): Int = 1282 + def foo1281(): Int = 1283 + def foo1282(): Int = 1284 + def foo1283(): Int = 1285 + def foo1284(): Int = 1286 + def foo1285(): Int = 1287 + def foo1286(): Int = 1288 + def foo1287(): Int = 1289 + def foo1288(): Int = 1290 + def foo1289(): Int = 1291 + def foo1290(): Int = 1292 + def foo1291(): Int = 1293 + def foo1292(): Int = 1294 + def foo1293(): Int = 1295 + def foo1294(): Int = 1296 + def foo1295(): Int = 1297 + def foo1296(): Int = 1298 + def foo1297(): Int = 1299 + def foo1298(): Int = 1300 + def foo1299(): Int = 1301 + def foo1300(): Int = 1302 + def foo1301(): Int = 1303 + def foo1302(): Int = 1304 + def foo1303(): Int = 1305 + def foo1304(): Int = 1306 + def foo1305(): Int = 1307 + def foo1306(): Int = 1308 + def foo1307(): Int = 1309 + def foo1308(): Int = 1310 + def foo1309(): Int = 1311 + def foo1310(): Int = 1312 + def foo1311(): Int = 1313 + def foo1312(): Int = 1314 + def foo1313(): Int = 1315 + def foo1314(): Int = 1316 + def foo1315(): Int = 1317 + def foo1316(): Int = 1318 + def foo1317(): Int = 1319 + def foo1318(): Int = 1320 + def foo1319(): Int = 1321 + def foo1320(): Int = 1322 + def foo1321(): Int = 1323 + def foo1322(): Int = 1324 + def foo1323(): Int = 1325 + def foo1324(): Int = 1326 + def foo1325(): Int = 1327 + def foo1326(): Int = 1328 + def foo1327(): Int = 1329 + def foo1328(): Int = 1330 + def foo1329(): Int = 1331 + def foo1330(): Int = 1332 + def foo1331(): Int = 1333 + def foo1332(): Int = 1334 + def foo1333(): Int = 1335 + def foo1334(): Int = 1336 + def foo1335(): Int = 1337 + def foo1336(): Int = 1338 + def foo1337(): Int = 1339 + def foo1338(): Int = 1340 + def foo1339(): Int = 1341 + def foo1340(): Int = 1342 + def foo1341(): Int = 1343 + def foo1342(): Int = 1344 + def foo1343(): Int = 1345 + def foo1344(): Int = 1346 + def foo1345(): Int = 1347 + def foo1346(): Int = 1348 + def foo1347(): Int = 1349 + def foo1348(): Int = 1350 + def foo1349(): Int = 1351 + def foo1350(): Int = 1352 + def foo1351(): Int = 1353 + def foo1352(): Int = 1354 + def foo1353(): Int = 1355 + def foo1354(): Int = 1356 + def foo1355(): Int = 1357 + def foo1356(): Int = 1358 + def foo1357(): Int = 1359 + def foo1358(): Int = 1360 + def foo1359(): Int = 1361 + def foo1360(): Int = 1362 + def foo1361(): Int = 1363 + def foo1362(): Int = 1364 + def foo1363(): Int = 1365 + def foo1364(): Int = 1366 + def foo1365(): Int = 1367 + def foo1366(): Int = 1368 + def foo1367(): Int = 1369 + def foo1368(): Int = 1370 + def foo1369(): Int = 1371 + def foo1370(): Int = 1372 + def foo1371(): Int = 1373 + def foo1372(): Int = 1374 + def foo1373(): Int = 1375 + def foo1374(): Int = 1376 + def foo1375(): Int = 1377 + def foo1376(): Int = 1378 + def foo1377(): Int = 1379 + def foo1378(): Int = 1380 + def foo1379(): Int = 1381 + def foo1380(): Int = 1382 + def foo1381(): Int = 1383 + def foo1382(): Int = 1384 + def foo1383(): Int = 1385 + def foo1384(): Int = 1386 + def foo1385(): Int = 1387 + def foo1386(): Int = 1388 + def foo1387(): Int = 1389 + def foo1388(): Int = 1390 + def foo1389(): Int = 1391 + def foo1390(): Int = 1392 + def foo1391(): Int = 1393 + def foo1392(): Int = 1394 + def foo1393(): Int = 1395 + def foo1394(): Int = 1396 + def foo1395(): Int = 1397 + def foo1396(): Int = 1398 + def foo1397(): Int = 1399 + def foo1398(): Int = 1400 + def foo1399(): Int = 1401 + def foo1400(): Int = 1402 + def foo1401(): Int = 1403 + def foo1402(): Int = 1404 + def foo1403(): Int = 1405 + def foo1404(): Int = 1406 + def foo1405(): Int = 1407 + def foo1406(): Int = 1408 + def foo1407(): Int = 1409 + def foo1408(): Int = 1410 + def foo1409(): Int = 1411 + def foo1410(): Int = 1412 + def foo1411(): Int = 1413 + def foo1412(): Int = 1414 + def foo1413(): Int = 1415 + def foo1414(): Int = 1416 + def foo1415(): Int = 1417 + def foo1416(): Int = 1418 + def foo1417(): Int = 1419 + def foo1418(): Int = 1420 + def foo1419(): Int = 1421 + def foo1420(): Int = 1422 + def foo1421(): Int = 1423 + def foo1422(): Int = 1424 + def foo1423(): Int = 1425 + def foo1424(): Int = 1426 + def foo1425(): Int = 1427 + def foo1426(): Int = 1428 + def foo1427(): Int = 1429 + def foo1428(): Int = 1430 + def foo1429(): Int = 1431 + def foo1430(): Int = 1432 + def foo1431(): Int = 1433 + def foo1432(): Int = 1434 + def foo1433(): Int = 1435 + def foo1434(): Int = 1436 + def foo1435(): Int = 1437 + def foo1436(): Int = 1438 + def foo1437(): Int = 1439 + def foo1438(): Int = 1440 + def foo1439(): Int = 1441 + def foo1440(): Int = 1442 + def foo1441(): Int = 1443 + def foo1442(): Int = 1444 + def foo1443(): Int = 1445 + def foo1444(): Int = 1446 + def foo1445(): Int = 1447 + def foo1446(): Int = 1448 + def foo1447(): Int = 1449 + def foo1448(): Int = 1450 + def foo1449(): Int = 1451 + def foo1450(): Int = 1452 + def foo1451(): Int = 1453 + def foo1452(): Int = 1454 + def foo1453(): Int = 1455 + def foo1454(): Int = 1456 + def foo1455(): Int = 1457 + def foo1456(): Int = 1458 + def foo1457(): Int = 1459 + def foo1458(): Int = 1460 + def foo1459(): Int = 1461 + def foo1460(): Int = 1462 + def foo1461(): Int = 1463 + def foo1462(): Int = 1464 + def foo1463(): Int = 1465 + def foo1464(): Int = 1466 + def foo1465(): Int = 1467 + def foo1466(): Int = 1468 + def foo1467(): Int = 1469 + def foo1468(): Int = 1470 + def foo1469(): Int = 1471 + def foo1470(): Int = 1472 + def foo1471(): Int = 1473 + def foo1472(): Int = 1474 + def foo1473(): Int = 1475 + def foo1474(): Int = 1476 + def foo1475(): Int = 1477 + def foo1476(): Int = 1478 + def foo1477(): Int = 1479 + def foo1478(): Int = 1480 + def foo1479(): Int = 1481 + def foo1480(): Int = 1482 + def foo1481(): Int = 1483 + def foo1482(): Int = 1484 + def foo1483(): Int = 1485 + def foo1484(): Int = 1486 + def foo1485(): Int = 1487 + def foo1486(): Int = 1488 + def foo1487(): Int = 1489 + def foo1488(): Int = 1490 + def foo1489(): Int = 1491 + def foo1490(): Int = 1492 + def foo1491(): Int = 1493 + def foo1492(): Int = 1494 + def foo1493(): Int = 1495 + def foo1494(): Int = 1496 + def foo1495(): Int = 1497 + def foo1496(): Int = 1498 + def foo1497(): Int = 1499 + def foo1498(): Int = 1500 + def foo1499(): Int = 1501 + def foo1500(): Int = 1502 + def foo1501(): Int = 1503 + def foo1502(): Int = 1504 + def foo1503(): Int = 1505 + def foo1504(): Int = 1506 + def foo1505(): Int = 1507 + def foo1506(): Int = 1508 + def foo1507(): Int = 1509 + def foo1508(): Int = 1510 + def foo1509(): Int = 1511 + def foo1510(): Int = 1512 + def foo1511(): Int = 1513 + def foo1512(): Int = 1514 + def foo1513(): Int = 1515 + def foo1514(): Int = 1516 + def foo1515(): Int = 1517 + def foo1516(): Int = 1518 + def foo1517(): Int = 1519 + def foo1518(): Int = 1520 + def foo1519(): Int = 1521 + def foo1520(): Int = 1522 + def foo1521(): Int = 1523 + def foo1522(): Int = 1524 + def foo1523(): Int = 1525 + def foo1524(): Int = 1526 + def foo1525(): Int = 1527 + def foo1526(): Int = 1528 + def foo1527(): Int = 1529 + def foo1528(): Int = 1530 + def foo1529(): Int = 1531 + def foo1530(): Int = 1532 + def foo1531(): Int = 1533 + def foo1532(): Int = 1534 + def foo1533(): Int = 1535 + def foo1534(): Int = 1536 + def foo1535(): Int = 1537 + def foo1536(): Int = 1538 + def foo1537(): Int = 1539 + def foo1538(): Int = 1540 + def foo1539(): Int = 1541 + def foo1540(): Int = 1542 + def foo1541(): Int = 1543 + def foo1542(): Int = 1544 + def foo1543(): Int = 1545 + def foo1544(): Int = 1546 + def foo1545(): Int = 1547 + def foo1546(): Int = 1548 + def foo1547(): Int = 1549 + def foo1548(): Int = 1550 + def foo1549(): Int = 1551 + def foo1550(): Int = 1552 + def foo1551(): Int = 1553 + def foo1552(): Int = 1554 + def foo1553(): Int = 1555 + def foo1554(): Int = 1556 + def foo1555(): Int = 1557 + def foo1556(): Int = 1558 + def foo1557(): Int = 1559 + def foo1558(): Int = 1560 + def foo1559(): Int = 1561 + def foo1560(): Int = 1562 + def foo1561(): Int = 1563 + def foo1562(): Int = 1564 + def foo1563(): Int = 1565 + def foo1564(): Int = 1566 + def foo1565(): Int = 1567 + def foo1566(): Int = 1568 + def foo1567(): Int = 1569 + def foo1568(): Int = 1570 + def foo1569(): Int = 1571 + def foo1570(): Int = 1572 + def foo1571(): Int = 1573 + def foo1572(): Int = 1574 + def foo1573(): Int = 1575 + def foo1574(): Int = 1576 + def foo1575(): Int = 1577 + def foo1576(): Int = 1578 + def foo1577(): Int = 1579 + def foo1578(): Int = 1580 + def foo1579(): Int = 1581 + def foo1580(): Int = 1582 + def foo1581(): Int = 1583 + def foo1582(): Int = 1584 + def foo1583(): Int = 1585 + def foo1584(): Int = 1586 + def foo1585(): Int = 1587 + def foo1586(): Int = 1588 + def foo1587(): Int = 1589 + def foo1588(): Int = 1590 + def foo1589(): Int = 1591 + def foo1590(): Int = 1592 + def foo1591(): Int = 1593 + def foo1592(): Int = 1594 + def foo1593(): Int = 1595 + def foo1594(): Int = 1596 + def foo1595(): Int = 1597 + def foo1596(): Int = 1598 + def foo1597(): Int = 1599 + def foo1598(): Int = 1600 + def foo1599(): Int = 1601 + def foo1600(): Int = 1602 + def foo1601(): Int = 1603 + def foo1602(): Int = 1604 + def foo1603(): Int = 1605 + def foo1604(): Int = 1606 + def foo1605(): Int = 1607 + def foo1606(): Int = 1608 + def foo1607(): Int = 1609 + def foo1608(): Int = 1610 + def foo1609(): Int = 1611 + def foo1610(): Int = 1612 + def foo1611(): Int = 1613 + def foo1612(): Int = 1614 + def foo1613(): Int = 1615 + def foo1614(): Int = 1616 + def foo1615(): Int = 1617 + def foo1616(): Int = 1618 + def foo1617(): Int = 1619 + def foo1618(): Int = 1620 + def foo1619(): Int = 1621 + def foo1620(): Int = 1622 + def foo1621(): Int = 1623 + def foo1622(): Int = 1624 + def foo1623(): Int = 1625 + def foo1624(): Int = 1626 + def foo1625(): Int = 1627 + def foo1626(): Int = 1628 + def foo1627(): Int = 1629 + def foo1628(): Int = 1630 + def foo1629(): Int = 1631 + def foo1630(): Int = 1632 + def foo1631(): Int = 1633 + def foo1632(): Int = 1634 + def foo1633(): Int = 1635 + def foo1634(): Int = 1636 + def foo1635(): Int = 1637 + def foo1636(): Int = 1638 + def foo1637(): Int = 1639 + def foo1638(): Int = 1640 + def foo1639(): Int = 1641 + def foo1640(): Int = 1642 + def foo1641(): Int = 1643 + def foo1642(): Int = 1644 + def foo1643(): Int = 1645 + def foo1644(): Int = 1646 + def foo1645(): Int = 1647 + def foo1646(): Int = 1648 + def foo1647(): Int = 1649 + def foo1648(): Int = 1650 + def foo1649(): Int = 1651 + def foo1650(): Int = 1652 + def foo1651(): Int = 1653 + def foo1652(): Int = 1654 + def foo1653(): Int = 1655 + def foo1654(): Int = 1656 + def foo1655(): Int = 1657 + def foo1656(): Int = 1658 + def foo1657(): Int = 1659 + def foo1658(): Int = 1660 + def foo1659(): Int = 1661 + def foo1660(): Int = 1662 + def foo1661(): Int = 1663 + def foo1662(): Int = 1664 + def foo1663(): Int = 1665 + def foo1664(): Int = 1666 + def foo1665(): Int = 1667 + def foo1666(): Int = 1668 + def foo1667(): Int = 1669 + def foo1668(): Int = 1670 + def foo1669(): Int = 1671 + def foo1670(): Int = 1672 + def foo1671(): Int = 1673 + def foo1672(): Int = 1674 + def foo1673(): Int = 1675 + def foo1674(): Int = 1676 + def foo1675(): Int = 1677 + def foo1676(): Int = 1678 + def foo1677(): Int = 1679 + def foo1678(): Int = 1680 + def foo1679(): Int = 1681 + def foo1680(): Int = 1682 + def foo1681(): Int = 1683 + def foo1682(): Int = 1684 + def foo1683(): Int = 1685 + def foo1684(): Int = 1686 + def foo1685(): Int = 1687 + def foo1686(): Int = 1688 + def foo1687(): Int = 1689 + def foo1688(): Int = 1690 + def foo1689(): Int = 1691 + def foo1690(): Int = 1692 + def foo1691(): Int = 1693 + def foo1692(): Int = 1694 + def foo1693(): Int = 1695 + def foo1694(): Int = 1696 + def foo1695(): Int = 1697 + def foo1696(): Int = 1698 + def foo1697(): Int = 1699 + def foo1698(): Int = 1700 + def foo1699(): Int = 1701 + def foo1700(): Int = 1702 + def foo1701(): Int = 1703 + def foo1702(): Int = 1704 + def foo1703(): Int = 1705 + def foo1704(): Int = 1706 + def foo1705(): Int = 1707 + def foo1706(): Int = 1708 + def foo1707(): Int = 1709 + def foo1708(): Int = 1710 + def foo1709(): Int = 1711 + def foo1710(): Int = 1712 + def foo1711(): Int = 1713 + def foo1712(): Int = 1714 + def foo1713(): Int = 1715 + def foo1714(): Int = 1716 + def foo1715(): Int = 1717 + def foo1716(): Int = 1718 + def foo1717(): Int = 1719 + def foo1718(): Int = 1720 + def foo1719(): Int = 1721 + def foo1720(): Int = 1722 + def foo1721(): Int = 1723 + def foo1722(): Int = 1724 + def foo1723(): Int = 1725 + def foo1724(): Int = 1726 + def foo1725(): Int = 1727 + def foo1726(): Int = 1728 + def foo1727(): Int = 1729 + def foo1728(): Int = 1730 + def foo1729(): Int = 1731 + def foo1730(): Int = 1732 + def foo1731(): Int = 1733 + def foo1732(): Int = 1734 + def foo1733(): Int = 1735 + def foo1734(): Int = 1736 + def foo1735(): Int = 1737 + def foo1736(): Int = 1738 + def foo1737(): Int = 1739 + def foo1738(): Int = 1740 + def foo1739(): Int = 1741 + def foo1740(): Int = 1742 + def foo1741(): Int = 1743 + def foo1742(): Int = 1744 + def foo1743(): Int = 1745 + def foo1744(): Int = 1746 + def foo1745(): Int = 1747 + def foo1746(): Int = 1748 + def foo1747(): Int = 1749 + def foo1748(): Int = 1750 + def foo1749(): Int = 1751 + def foo1750(): Int = 1752 + def foo1751(): Int = 1753 + def foo1752(): Int = 1754 + def foo1753(): Int = 1755 + def foo1754(): Int = 1756 + def foo1755(): Int = 1757 + def foo1756(): Int = 1758 + def foo1757(): Int = 1759 + def foo1758(): Int = 1760 + def foo1759(): Int = 1761 + def foo1760(): Int = 1762 + def foo1761(): Int = 1763 + def foo1762(): Int = 1764 + def foo1763(): Int = 1765 + def foo1764(): Int = 1766 + def foo1765(): Int = 1767 + def foo1766(): Int = 1768 + def foo1767(): Int = 1769 + def foo1768(): Int = 1770 + def foo1769(): Int = 1771 + def foo1770(): Int = 1772 + def foo1771(): Int = 1773 + def foo1772(): Int = 1774 + def foo1773(): Int = 1775 + def foo1774(): Int = 1776 + def foo1775(): Int = 1777 + def foo1776(): Int = 1778 + def foo1777(): Int = 1779 + def foo1778(): Int = 1780 + def foo1779(): Int = 1781 + def foo1780(): Int = 1782 + def foo1781(): Int = 1783 + def foo1782(): Int = 1784 + def foo1783(): Int = 1785 + def foo1784(): Int = 1786 + def foo1785(): Int = 1787 + def foo1786(): Int = 1788 + def foo1787(): Int = 1789 + def foo1788(): Int = 1790 + def foo1789(): Int = 1791 + def foo1790(): Int = 1792 + def foo1791(): Int = 1793 + def foo1792(): Int = 1794 + def foo1793(): Int = 1795 + def foo1794(): Int = 1796 + def foo1795(): Int = 1797 + def foo1796(): Int = 1798 + def foo1797(): Int = 1799 + def foo1798(): Int = 1800 + def foo1799(): Int = 1801 + def foo1800(): Int = 1802 + def foo1801(): Int = 1803 + def foo1802(): Int = 1804 + def foo1803(): Int = 1805 + def foo1804(): Int = 1806 + def foo1805(): Int = 1807 + def foo1806(): Int = 1808 + def foo1807(): Int = 1809 + def foo1808(): Int = 1810 + def foo1809(): Int = 1811 + def foo1810(): Int = 1812 + def foo1811(): Int = 1813 + def foo1812(): Int = 1814 + def foo1813(): Int = 1815 + def foo1814(): Int = 1816 + def foo1815(): Int = 1817 + def foo1816(): Int = 1818 + def foo1817(): Int = 1819 + def foo1818(): Int = 1820 + def foo1819(): Int = 1821 + def foo1820(): Int = 1822 + def foo1821(): Int = 1823 + def foo1822(): Int = 1824 + def foo1823(): Int = 1825 + def foo1824(): Int = 1826 + def foo1825(): Int = 1827 + def foo1826(): Int = 1828 + def foo1827(): Int = 1829 + def foo1828(): Int = 1830 + def foo1829(): Int = 1831 + def foo1830(): Int = 1832 + def foo1831(): Int = 1833 + def foo1832(): Int = 1834 + def foo1833(): Int = 1835 + def foo1834(): Int = 1836 + def foo1835(): Int = 1837 + def foo1836(): Int = 1838 + def foo1837(): Int = 1839 + def foo1838(): Int = 1840 + def foo1839(): Int = 1841 + def foo1840(): Int = 1842 + def foo1841(): Int = 1843 + def foo1842(): Int = 1844 + def foo1843(): Int = 1845 + def foo1844(): Int = 1846 + def foo1845(): Int = 1847 + def foo1846(): Int = 1848 + def foo1847(): Int = 1849 + def foo1848(): Int = 1850 + def foo1849(): Int = 1851 + def foo1850(): Int = 1852 + def foo1851(): Int = 1853 + def foo1852(): Int = 1854 + def foo1853(): Int = 1855 + def foo1854(): Int = 1856 + def foo1855(): Int = 1857 + def foo1856(): Int = 1858 + def foo1857(): Int = 1859 + def foo1858(): Int = 1860 + def foo1859(): Int = 1861 + def foo1860(): Int = 1862 + def foo1861(): Int = 1863 + def foo1862(): Int = 1864 + def foo1863(): Int = 1865 + def foo1864(): Int = 1866 + def foo1865(): Int = 1867 + def foo1866(): Int = 1868 + def foo1867(): Int = 1869 + def foo1868(): Int = 1870 + def foo1869(): Int = 1871 + def foo1870(): Int = 1872 + def foo1871(): Int = 1873 + def foo1872(): Int = 1874 + def foo1873(): Int = 1875 + def foo1874(): Int = 1876 + def foo1875(): Int = 1877 + def foo1876(): Int = 1878 + def foo1877(): Int = 1879 + def foo1878(): Int = 1880 + def foo1879(): Int = 1881 + def foo1880(): Int = 1882 + def foo1881(): Int = 1883 + def foo1882(): Int = 1884 + def foo1883(): Int = 1885 + def foo1884(): Int = 1886 + def foo1885(): Int = 1887 + def foo1886(): Int = 1888 + def foo1887(): Int = 1889 + def foo1888(): Int = 1890 + def foo1889(): Int = 1891 + def foo1890(): Int = 1892 + def foo1891(): Int = 1893 + def foo1892(): Int = 1894 + def foo1893(): Int = 1895 + def foo1894(): Int = 1896 + def foo1895(): Int = 1897 + def foo1896(): Int = 1898 + def foo1897(): Int = 1899 + def foo1898(): Int = 1900 + def foo1899(): Int = 1901 + def foo1900(): Int = 1902 + def foo1901(): Int = 1903 + def foo1902(): Int = 1904 + def foo1903(): Int = 1905 + def foo1904(): Int = 1906 + def foo1905(): Int = 1907 + def foo1906(): Int = 1908 + def foo1907(): Int = 1909 + def foo1908(): Int = 1910 + def foo1909(): Int = 1911 + def foo1910(): Int = 1912 + def foo1911(): Int = 1913 + def foo1912(): Int = 1914 + def foo1913(): Int = 1915 + def foo1914(): Int = 1916 + def foo1915(): Int = 1917 + def foo1916(): Int = 1918 + def foo1917(): Int = 1919 + def foo1918(): Int = 1920 + def foo1919(): Int = 1921 + def foo1920(): Int = 1922 + def foo1921(): Int = 1923 + def foo1922(): Int = 1924 + def foo1923(): Int = 1925 + def foo1924(): Int = 1926 + def foo1925(): Int = 1927 + def foo1926(): Int = 1928 + def foo1927(): Int = 1929 + def foo1928(): Int = 1930 + def foo1929(): Int = 1931 + def foo1930(): Int = 1932 + def foo1931(): Int = 1933 + def foo1932(): Int = 1934 + def foo1933(): Int = 1935 + def foo1934(): Int = 1936 + def foo1935(): Int = 1937 + def foo1936(): Int = 1938 + def foo1937(): Int = 1939 + def foo1938(): Int = 1940 + def foo1939(): Int = 1941 + def foo1940(): Int = 1942 + def foo1941(): Int = 1943 + def foo1942(): Int = 1944 + def foo1943(): Int = 1945 + def foo1944(): Int = 1946 + def foo1945(): Int = 1947 + def foo1946(): Int = 1948 + def foo1947(): Int = 1949 + def foo1948(): Int = 1950 + def foo1949(): Int = 1951 + def foo1950(): Int = 1952 + def foo1951(): Int = 1953 + def foo1952(): Int = 1954 + def foo1953(): Int = 1955 + def foo1954(): Int = 1956 + def foo1955(): Int = 1957 + def foo1956(): Int = 1958 + def foo1957(): Int = 1959 + def foo1958(): Int = 1960 + def foo1959(): Int = 1961 + def foo1960(): Int = 1962 + def foo1961(): Int = 1963 + def foo1962(): Int = 1964 + def foo1963(): Int = 1965 + def foo1964(): Int = 1966 + def foo1965(): Int = 1967 + def foo1966(): Int = 1968 + def foo1967(): Int = 1969 + def foo1968(): Int = 1970 + def foo1969(): Int = 1971 + def foo1970(): Int = 1972 + def foo1971(): Int = 1973 + def foo1972(): Int = 1974 + def foo1973(): Int = 1975 + def foo1974(): Int = 1976 + def foo1975(): Int = 1977 + def foo1976(): Int = 1978 + def foo1977(): Int = 1979 + def foo1978(): Int = 1980 + def foo1979(): Int = 1981 + def foo1980(): Int = 1982 + def foo1981(): Int = 1983 + def foo1982(): Int = 1984 + def foo1983(): Int = 1985 + def foo1984(): Int = 1986 + def foo1985(): Int = 1987 + def foo1986(): Int = 1988 + def foo1987(): Int = 1989 + def foo1988(): Int = 1990 + def foo1989(): Int = 1991 + def foo1990(): Int = 1992 + def foo1991(): Int = 1993 + def foo1992(): Int = 1994 + def foo1993(): Int = 1995 + def foo1994(): Int = 1996 + def foo1995(): Int = 1997 + def foo1996(): Int = 1998 + def foo1997(): Int = 1999 + def foo1998(): Int = 2000 + def foo1999(): Int = 2001 + def foo2000(): Int = 2002 + def foo2001(): Int = 2003 + def foo2002(): Int = 2004 + def foo2003(): Int = 2005 + def foo2004(): Int = 2006 + def foo2005(): Int = 2007 + def foo2006(): Int = 2008 + def foo2007(): Int = 2009 + def foo2008(): Int = 2010 + def foo2009(): Int = 2011 + def foo2010(): Int = 2012 + def foo2011(): Int = 2013 + def foo2012(): Int = 2014 + def foo2013(): Int = 2015 + def foo2014(): Int = 2016 + def foo2015(): Int = 2017 + def foo2016(): Int = 2018 + def foo2017(): Int = 2019 + def foo2018(): Int = 2020 + def foo2019(): Int = 2021 + def foo2020(): Int = 2022 + def foo2021(): Int = 2023 + def foo2022(): Int = 2024 + def foo2023(): Int = 2025 + def foo2024(): Int = 2026 + def foo2025(): Int = 2027 + def foo2026(): Int = 2028 + def foo2027(): Int = 2029 + def foo2028(): Int = 2030 + def foo2029(): Int = 2031 + def foo2030(): Int = 2032 + def foo2031(): Int = 2033 + def foo2032(): Int = 2034 + def foo2033(): Int = 2035 + def foo2034(): Int = 2036 + def foo2035(): Int = 2037 + def foo2036(): Int = 2038 + def foo2037(): Int = 2039 + def foo2038(): Int = 2040 + def foo2039(): Int = 2041 + def foo2040(): Int = 2042 + def foo2041(): Int = 2043 + def foo2042(): Int = 2044 + def foo2043(): Int = 2045 + def foo2044(): Int = 2046 + def foo2045(): Int = 2047 + def foo2046(): Int = 2048 + def foo2047(): Int = 2049 + def foo2048(): Int = 2050 + def foo2049(): Int = 2051 + def foo2050(): Int = 2052 + def foo2051(): Int = 2053 + def foo2052(): Int = 2054 + def foo2053(): Int = 2055 + def foo2054(): Int = 2056 + def foo2055(): Int = 2057 + def foo2056(): Int = 2058 + def foo2057(): Int = 2059 + def foo2058(): Int = 2060 + def foo2059(): Int = 2061 + def foo2060(): Int = 2062 + def foo2061(): Int = 2063 + def foo2062(): Int = 2064 + def foo2063(): Int = 2065 + def foo2064(): Int = 2066 + def foo2065(): Int = 2067 + def foo2066(): Int = 2068 + def foo2067(): Int = 2069 + def foo2068(): Int = 2070 + def foo2069(): Int = 2071 + def foo2070(): Int = 2072 + def foo2071(): Int = 2073 + def foo2072(): Int = 2074 + def foo2073(): Int = 2075 + def foo2074(): Int = 2076 + def foo2075(): Int = 2077 + def foo2076(): Int = 2078 + def foo2077(): Int = 2079 + def foo2078(): Int = 2080 + def foo2079(): Int = 2081 + def foo2080(): Int = 2082 + def foo2081(): Int = 2083 + def foo2082(): Int = 2084 + def foo2083(): Int = 2085 + def foo2084(): Int = 2086 + def foo2085(): Int = 2087 + def foo2086(): Int = 2088 + def foo2087(): Int = 2089 + def foo2088(): Int = 2090 + def foo2089(): Int = 2091 + def foo2090(): Int = 2092 + def foo2091(): Int = 2093 + def foo2092(): Int = 2094 + def foo2093(): Int = 2095 + def foo2094(): Int = 2096 + def foo2095(): Int = 2097 + def foo2096(): Int = 2098 + def foo2097(): Int = 2099 + def foo2098(): Int = 2100 + def foo2099(): Int = 2101 + def foo2100(): Int = 2102 + def foo2101(): Int = 2103 + def foo2102(): Int = 2104 + def foo2103(): Int = 2105 + def foo2104(): Int = 2106 + def foo2105(): Int = 2107 + def foo2106(): Int = 2108 + def foo2107(): Int = 2109 + def foo2108(): Int = 2110 + def foo2109(): Int = 2111 + def foo2110(): Int = 2112 + def foo2111(): Int = 2113 + def foo2112(): Int = 2114 + def foo2113(): Int = 2115 + def foo2114(): Int = 2116 + def foo2115(): Int = 2117 + def foo2116(): Int = 2118 + def foo2117(): Int = 2119 + def foo2118(): Int = 2120 + def foo2119(): Int = 2121 + def foo2120(): Int = 2122 + def foo2121(): Int = 2123 + def foo2122(): Int = 2124 + def foo2123(): Int = 2125 + def foo2124(): Int = 2126 + def foo2125(): Int = 2127 + def foo2126(): Int = 2128 + def foo2127(): Int = 2129 + def foo2128(): Int = 2130 + def foo2129(): Int = 2131 + def foo2130(): Int = 2132 + def foo2131(): Int = 2133 + def foo2132(): Int = 2134 + def foo2133(): Int = 2135 + def foo2134(): Int = 2136 + def foo2135(): Int = 2137 + def foo2136(): Int = 2138 + def foo2137(): Int = 2139 + def foo2138(): Int = 2140 + def foo2139(): Int = 2141 + def foo2140(): Int = 2142 + def foo2141(): Int = 2143 + def foo2142(): Int = 2144 + def foo2143(): Int = 2145 + def foo2144(): Int = 2146 + def foo2145(): Int = 2147 + def foo2146(): Int = 2148 + def foo2147(): Int = 2149 + def foo2148(): Int = 2150 + def foo2149(): Int = 2151 + def foo2150(): Int = 2152 + def foo2151(): Int = 2153 + def foo2152(): Int = 2154 + def foo2153(): Int = 2155 + def foo2154(): Int = 2156 + def foo2155(): Int = 2157 + def foo2156(): Int = 2158 + def foo2157(): Int = 2159 + def foo2158(): Int = 2160 + def foo2159(): Int = 2161 + def foo2160(): Int = 2162 + def foo2161(): Int = 2163 + def foo2162(): Int = 2164 + def foo2163(): Int = 2165 + def foo2164(): Int = 2166 + def foo2165(): Int = 2167 + def foo2166(): Int = 2168 + def foo2167(): Int = 2169 + def foo2168(): Int = 2170 + def foo2169(): Int = 2171 + def foo2170(): Int = 2172 + def foo2171(): Int = 2173 + def foo2172(): Int = 2174 + def foo2173(): Int = 2175 + def foo2174(): Int = 2176 + def foo2175(): Int = 2177 + def foo2176(): Int = 2178 + def foo2177(): Int = 2179 + def foo2178(): Int = 2180 + def foo2179(): Int = 2181 + def foo2180(): Int = 2182 + def foo2181(): Int = 2183 + def foo2182(): Int = 2184 + def foo2183(): Int = 2185 + def foo2184(): Int = 2186 + def foo2185(): Int = 2187 + def foo2186(): Int = 2188 + def foo2187(): Int = 2189 + def foo2188(): Int = 2190 + def foo2189(): Int = 2191 + def foo2190(): Int = 2192 + def foo2191(): Int = 2193 + def foo2192(): Int = 2194 + def foo2193(): Int = 2195 + def foo2194(): Int = 2196 + def foo2195(): Int = 2197 + def foo2196(): Int = 2198 + def foo2197(): Int = 2199 + def foo2198(): Int = 2200 + def foo2199(): Int = 2201 + def foo2200(): Int = 2202 + def foo2201(): Int = 2203 + def foo2202(): Int = 2204 + def foo2203(): Int = 2205 + def foo2204(): Int = 2206 + def foo2205(): Int = 2207 + def foo2206(): Int = 2208 + def foo2207(): Int = 2209 + def foo2208(): Int = 2210 + def foo2209(): Int = 2211 + def foo2210(): Int = 2212 + def foo2211(): Int = 2213 + def foo2212(): Int = 2214 + def foo2213(): Int = 2215 + def foo2214(): Int = 2216 + def foo2215(): Int = 2217 + def foo2216(): Int = 2218 + def foo2217(): Int = 2219 + def foo2218(): Int = 2220 + def foo2219(): Int = 2221 + def foo2220(): Int = 2222 + def foo2221(): Int = 2223 + def foo2222(): Int = 2224 + def foo2223(): Int = 2225 + def foo2224(): Int = 2226 + def foo2225(): Int = 2227 + def foo2226(): Int = 2228 + def foo2227(): Int = 2229 + def foo2228(): Int = 2230 + def foo2229(): Int = 2231 + def foo2230(): Int = 2232 + def foo2231(): Int = 2233 + def foo2232(): Int = 2234 + def foo2233(): Int = 2235 + def foo2234(): Int = 2236 + def foo2235(): Int = 2237 + def foo2236(): Int = 2238 + def foo2237(): Int = 2239 + def foo2238(): Int = 2240 + def foo2239(): Int = 2241 + def foo2240(): Int = 2242 + def foo2241(): Int = 2243 + def foo2242(): Int = 2244 + def foo2243(): Int = 2245 + def foo2244(): Int = 2246 + def foo2245(): Int = 2247 + def foo2246(): Int = 2248 + def foo2247(): Int = 2249 + def foo2248(): Int = 2250 + def foo2249(): Int = 2251 + def foo2250(): Int = 2252 + def foo2251(): Int = 2253 + def foo2252(): Int = 2254 + def foo2253(): Int = 2255 + def foo2254(): Int = 2256 + def foo2255(): Int = 2257 + def foo2256(): Int = 2258 + def foo2257(): Int = 2259 + def foo2258(): Int = 2260 + def foo2259(): Int = 2261 + def foo2260(): Int = 2262 + def foo2261(): Int = 2263 + def foo2262(): Int = 2264 + def foo2263(): Int = 2265 + def foo2264(): Int = 2266 + def foo2265(): Int = 2267 + def foo2266(): Int = 2268 + def foo2267(): Int = 2269 + def foo2268(): Int = 2270 + def foo2269(): Int = 2271 + def foo2270(): Int = 2272 + def foo2271(): Int = 2273 + def foo2272(): Int = 2274 + def foo2273(): Int = 2275 + def foo2274(): Int = 2276 + def foo2275(): Int = 2277 + def foo2276(): Int = 2278 + def foo2277(): Int = 2279 + def foo2278(): Int = 2280 + def foo2279(): Int = 2281 + def foo2280(): Int = 2282 + def foo2281(): Int = 2283 + def foo2282(): Int = 2284 + def foo2283(): Int = 2285 + def foo2284(): Int = 2286 + def foo2285(): Int = 2287 + def foo2286(): Int = 2288 + def foo2287(): Int = 2289 + def foo2288(): Int = 2290 + def foo2289(): Int = 2291 + def foo2290(): Int = 2292 + def foo2291(): Int = 2293 + def foo2292(): Int = 2294 + def foo2293(): Int = 2295 + def foo2294(): Int = 2296 + def foo2295(): Int = 2297 + def foo2296(): Int = 2298 + def foo2297(): Int = 2299 + def foo2298(): Int = 2300 + def foo2299(): Int = 2301 + def foo2300(): Int = 2302 + def foo2301(): Int = 2303 + def foo2302(): Int = 2304 + def foo2303(): Int = 2305 + def foo2304(): Int = 2306 + def foo2305(): Int = 2307 + def foo2306(): Int = 2308 + def foo2307(): Int = 2309 + def foo2308(): Int = 2310 + def foo2309(): Int = 2311 + def foo2310(): Int = 2312 + def foo2311(): Int = 2313 + def foo2312(): Int = 2314 + def foo2313(): Int = 2315 + def foo2314(): Int = 2316 + def foo2315(): Int = 2317 + def foo2316(): Int = 2318 + def foo2317(): Int = 2319 + def foo2318(): Int = 2320 + def foo2319(): Int = 2321 + def foo2320(): Int = 2322 + def foo2321(): Int = 2323 + def foo2322(): Int = 2324 + def foo2323(): Int = 2325 + def foo2324(): Int = 2326 + def foo2325(): Int = 2327 + def foo2326(): Int = 2328 + def foo2327(): Int = 2329 + def foo2328(): Int = 2330 + def foo2329(): Int = 2331 + def foo2330(): Int = 2332 + def foo2331(): Int = 2333 + def foo2332(): Int = 2334 + def foo2333(): Int = 2335 + def foo2334(): Int = 2336 + def foo2335(): Int = 2337 + def foo2336(): Int = 2338 + def foo2337(): Int = 2339 + def foo2338(): Int = 2340 + def foo2339(): Int = 2341 + def foo2340(): Int = 2342 + def foo2341(): Int = 2343 + def foo2342(): Int = 2344 + def foo2343(): Int = 2345 + def foo2344(): Int = 2346 + def foo2345(): Int = 2347 + def foo2346(): Int = 2348 + def foo2347(): Int = 2349 + def foo2348(): Int = 2350 + def foo2349(): Int = 2351 + def foo2350(): Int = 2352 + def foo2351(): Int = 2353 + def foo2352(): Int = 2354 + def foo2353(): Int = 2355 + def foo2354(): Int = 2356 + def foo2355(): Int = 2357 + def foo2356(): Int = 2358 + def foo2357(): Int = 2359 + def foo2358(): Int = 2360 + def foo2359(): Int = 2361 + def foo2360(): Int = 2362 + def foo2361(): Int = 2363 + def foo2362(): Int = 2364 + def foo2363(): Int = 2365 + def foo2364(): Int = 2366 + def foo2365(): Int = 2367 + def foo2366(): Int = 2368 + def foo2367(): Int = 2369 + def foo2368(): Int = 2370 + def foo2369(): Int = 2371 + def foo2370(): Int = 2372 + def foo2371(): Int = 2373 + def foo2372(): Int = 2374 + def foo2373(): Int = 2375 + def foo2374(): Int = 2376 + def foo2375(): Int = 2377 + def foo2376(): Int = 2378 + def foo2377(): Int = 2379 + def foo2378(): Int = 2380 + def foo2379(): Int = 2381 + def foo2380(): Int = 2382 + def foo2381(): Int = 2383 + def foo2382(): Int = 2384 + def foo2383(): Int = 2385 + def foo2384(): Int = 2386 + def foo2385(): Int = 2387 + def foo2386(): Int = 2388 + def foo2387(): Int = 2389 + def foo2388(): Int = 2390 + def foo2389(): Int = 2391 + def foo2390(): Int = 2392 + def foo2391(): Int = 2393 + def foo2392(): Int = 2394 + def foo2393(): Int = 2395 + def foo2394(): Int = 2396 + def foo2395(): Int = 2397 + def foo2396(): Int = 2398 + def foo2397(): Int = 2399 + def foo2398(): Int = 2400 + def foo2399(): Int = 2401 + def foo2400(): Int = 2402 + def foo2401(): Int = 2403 + def foo2402(): Int = 2404 + def foo2403(): Int = 2405 + def foo2404(): Int = 2406 + def foo2405(): Int = 2407 + def foo2406(): Int = 2408 + def foo2407(): Int = 2409 + def foo2408(): Int = 2410 + def foo2409(): Int = 2411 + def foo2410(): Int = 2412 + def foo2411(): Int = 2413 + def foo2412(): Int = 2414 + def foo2413(): Int = 2415 + def foo2414(): Int = 2416 + def foo2415(): Int = 2417 + def foo2416(): Int = 2418 + def foo2417(): Int = 2419 + def foo2418(): Int = 2420 + def foo2419(): Int = 2421 + def foo2420(): Int = 2422 + def foo2421(): Int = 2423 + def foo2422(): Int = 2424 + def foo2423(): Int = 2425 + def foo2424(): Int = 2426 + def foo2425(): Int = 2427 + def foo2426(): Int = 2428 + def foo2427(): Int = 2429 + def foo2428(): Int = 2430 + def foo2429(): Int = 2431 + def foo2430(): Int = 2432 + def foo2431(): Int = 2433 + def foo2432(): Int = 2434 + def foo2433(): Int = 2435 + def foo2434(): Int = 2436 + def foo2435(): Int = 2437 + def foo2436(): Int = 2438 + def foo2437(): Int = 2439 + def foo2438(): Int = 2440 + def foo2439(): Int = 2441 + def foo2440(): Int = 2442 + def foo2441(): Int = 2443 + def foo2442(): Int = 2444 + def foo2443(): Int = 2445 + def foo2444(): Int = 2446 + def foo2445(): Int = 2447 + def foo2446(): Int = 2448 + def foo2447(): Int = 2449 + def foo2448(): Int = 2450 + def foo2449(): Int = 2451 + def foo2450(): Int = 2452 + def foo2451(): Int = 2453 + def foo2452(): Int = 2454 + def foo2453(): Int = 2455 + def foo2454(): Int = 2456 + def foo2455(): Int = 2457 + def foo2456(): Int = 2458 + def foo2457(): Int = 2459 + def foo2458(): Int = 2460 + def foo2459(): Int = 2461 + def foo2460(): Int = 2462 + def foo2461(): Int = 2463 + def foo2462(): Int = 2464 + def foo2463(): Int = 2465 + def foo2464(): Int = 2466 + def foo2465(): Int = 2467 + def foo2466(): Int = 2468 + def foo2467(): Int = 2469 + def foo2468(): Int = 2470 + def foo2469(): Int = 2471 + def foo2470(): Int = 2472 + def foo2471(): Int = 2473 + def foo2472(): Int = 2474 + def foo2473(): Int = 2475 + def foo2474(): Int = 2476 + def foo2475(): Int = 2477 + def foo2476(): Int = 2478 + def foo2477(): Int = 2479 + def foo2478(): Int = 2480 + def foo2479(): Int = 2481 + def foo2480(): Int = 2482 + def foo2481(): Int = 2483 + def foo2482(): Int = 2484 + def foo2483(): Int = 2485 + def foo2484(): Int = 2486 + def foo2485(): Int = 2487 + def foo2486(): Int = 2488 + def foo2487(): Int = 2489 + def foo2488(): Int = 2490 + def foo2489(): Int = 2491 + def foo2490(): Int = 2492 + def foo2491(): Int = 2493 + def foo2492(): Int = 2494 + def foo2493(): Int = 2495 + def foo2494(): Int = 2496 + def foo2495(): Int = 2497 + def foo2496(): Int = 2498 + def foo2497(): Int = 2499 + def foo2498(): Int = 2500 + def foo2499(): Int = 2501 + def foo2500(): Int = 2502 + def foo2501(): Int = 2503 + def foo2502(): Int = 2504 + def foo2503(): Int = 2505 + def foo2504(): Int = 2506 + def foo2505(): Int = 2507 + def foo2506(): Int = 2508 + def foo2507(): Int = 2509 + def foo2508(): Int = 2510 + def foo2509(): Int = 2511 + def foo2510(): Int = 2512 + def foo2511(): Int = 2513 + def foo2512(): Int = 2514 + def foo2513(): Int = 2515 + def foo2514(): Int = 2516 + def foo2515(): Int = 2517 + def foo2516(): Int = 2518 + def foo2517(): Int = 2519 + def foo2518(): Int = 2520 + def foo2519(): Int = 2521 + def foo2520(): Int = 2522 + def foo2521(): Int = 2523 + def foo2522(): Int = 2524 + def foo2523(): Int = 2525 + def foo2524(): Int = 2526 + def foo2525(): Int = 2527 + def foo2526(): Int = 2528 + def foo2527(): Int = 2529 + def foo2528(): Int = 2530 + def foo2529(): Int = 2531 + def foo2530(): Int = 2532 + def foo2531(): Int = 2533 + def foo2532(): Int = 2534 + def foo2533(): Int = 2535 + def foo2534(): Int = 2536 + def foo2535(): Int = 2537 + def foo2536(): Int = 2538 + def foo2537(): Int = 2539 + def foo2538(): Int = 2540 + def foo2539(): Int = 2541 + def foo2540(): Int = 2542 + def foo2541(): Int = 2543 + def foo2542(): Int = 2544 + def foo2543(): Int = 2545 + def foo2544(): Int = 2546 + def foo2545(): Int = 2547 + def foo2546(): Int = 2548 + def foo2547(): Int = 2549 + def foo2548(): Int = 2550 + def foo2549(): Int = 2551 + def foo2550(): Int = 2552 + def foo2551(): Int = 2553 + def foo2552(): Int = 2554 + def foo2553(): Int = 2555 + def foo2554(): Int = 2556 + def foo2555(): Int = 2557 + def foo2556(): Int = 2558 + def foo2557(): Int = 2559 + def foo2558(): Int = 2560 + def foo2559(): Int = 2561 + def foo2560(): Int = 2562 + def foo2561(): Int = 2563 + def foo2562(): Int = 2564 + def foo2563(): Int = 2565 + def foo2564(): Int = 2566 + def foo2565(): Int = 2567 + def foo2566(): Int = 2568 + def foo2567(): Int = 2569 + def foo2568(): Int = 2570 + def foo2569(): Int = 2571 + def foo2570(): Int = 2572 + def foo2571(): Int = 2573 + def foo2572(): Int = 2574 + def foo2573(): Int = 2575 + def foo2574(): Int = 2576 + def foo2575(): Int = 2577 + def foo2576(): Int = 2578 + def foo2577(): Int = 2579 + def foo2578(): Int = 2580 + def foo2579(): Int = 2581 + def foo2580(): Int = 2582 + def foo2581(): Int = 2583 + def foo2582(): Int = 2584 + def foo2583(): Int = 2585 + def foo2584(): Int = 2586 + def foo2585(): Int = 2587 + def foo2586(): Int = 2588 + def foo2587(): Int = 2589 + def foo2588(): Int = 2590 + def foo2589(): Int = 2591 + def foo2590(): Int = 2592 + def foo2591(): Int = 2593 + def foo2592(): Int = 2594 + def foo2593(): Int = 2595 + def foo2594(): Int = 2596 + def foo2595(): Int = 2597 + def foo2596(): Int = 2598 + def foo2597(): Int = 2599 + def foo2598(): Int = 2600 + def foo2599(): Int = 2601 + def foo2600(): Int = 2602 + def foo2601(): Int = 2603 + def foo2602(): Int = 2604 + def foo2603(): Int = 2605 + def foo2604(): Int = 2606 + def foo2605(): Int = 2607 + def foo2606(): Int = 2608 + def foo2607(): Int = 2609 + def foo2608(): Int = 2610 + def foo2609(): Int = 2611 + def foo2610(): Int = 2612 + def foo2611(): Int = 2613 + def foo2612(): Int = 2614 + def foo2613(): Int = 2615 + def foo2614(): Int = 2616 + def foo2615(): Int = 2617 + def foo2616(): Int = 2618 + def foo2617(): Int = 2619 + def foo2618(): Int = 2620 + def foo2619(): Int = 2621 + def foo2620(): Int = 2622 + def foo2621(): Int = 2623 + def foo2622(): Int = 2624 + def foo2623(): Int = 2625 + def foo2624(): Int = 2626 + def foo2625(): Int = 2627 + def foo2626(): Int = 2628 + def foo2627(): Int = 2629 + def foo2628(): Int = 2630 + def foo2629(): Int = 2631 + def foo2630(): Int = 2632 + def foo2631(): Int = 2633 + def foo2632(): Int = 2634 + def foo2633(): Int = 2635 + def foo2634(): Int = 2636 + def foo2635(): Int = 2637 + def foo2636(): Int = 2638 + def foo2637(): Int = 2639 + def foo2638(): Int = 2640 + def foo2639(): Int = 2641 + def foo2640(): Int = 2642 + def foo2641(): Int = 2643 + def foo2642(): Int = 2644 + def foo2643(): Int = 2645 + def foo2644(): Int = 2646 + def foo2645(): Int = 2647 + def foo2646(): Int = 2648 + def foo2647(): Int = 2649 + def foo2648(): Int = 2650 + def foo2649(): Int = 2651 + def foo2650(): Int = 2652 + def foo2651(): Int = 2653 + def foo2652(): Int = 2654 + def foo2653(): Int = 2655 + def foo2654(): Int = 2656 + def foo2655(): Int = 2657 + def foo2656(): Int = 2658 + def foo2657(): Int = 2659 + def foo2658(): Int = 2660 + def foo2659(): Int = 2661 + def foo2660(): Int = 2662 + def foo2661(): Int = 2663 + def foo2662(): Int = 2664 + def foo2663(): Int = 2665 + def foo2664(): Int = 2666 + def foo2665(): Int = 2667 + def foo2666(): Int = 2668 + def foo2667(): Int = 2669 + def foo2668(): Int = 2670 + def foo2669(): Int = 2671 + def foo2670(): Int = 2672 + def foo2671(): Int = 2673 + def foo2672(): Int = 2674 + def foo2673(): Int = 2675 + def foo2674(): Int = 2676 + def foo2675(): Int = 2677 + def foo2676(): Int = 2678 + def foo2677(): Int = 2679 + def foo2678(): Int = 2680 + def foo2679(): Int = 2681 + def foo2680(): Int = 2682 + def foo2681(): Int = 2683 + def foo2682(): Int = 2684 + def foo2683(): Int = 2685 + def foo2684(): Int = 2686 + def foo2685(): Int = 2687 + def foo2686(): Int = 2688 + def foo2687(): Int = 2689 + def foo2688(): Int = 2690 + def foo2689(): Int = 2691 + def foo2690(): Int = 2692 + def foo2691(): Int = 2693 + def foo2692(): Int = 2694 + def foo2693(): Int = 2695 + def foo2694(): Int = 2696 + def foo2695(): Int = 2697 + def foo2696(): Int = 2698 + def foo2697(): Int = 2699 + def foo2698(): Int = 2700 + def foo2699(): Int = 2701 + def foo2700(): Int = 2702 + def foo2701(): Int = 2703 + def foo2702(): Int = 2704 + def foo2703(): Int = 2705 + def foo2704(): Int = 2706 + def foo2705(): Int = 2707 + def foo2706(): Int = 2708 + def foo2707(): Int = 2709 + def foo2708(): Int = 2710 + def foo2709(): Int = 2711 + def foo2710(): Int = 2712 + def foo2711(): Int = 2713 + def foo2712(): Int = 2714 + def foo2713(): Int = 2715 + def foo2714(): Int = 2716 + def foo2715(): Int = 2717 + def foo2716(): Int = 2718 + def foo2717(): Int = 2719 + def foo2718(): Int = 2720 + def foo2719(): Int = 2721 + def foo2720(): Int = 2722 + def foo2721(): Int = 2723 + def foo2722(): Int = 2724 + def foo2723(): Int = 2725 + def foo2724(): Int = 2726 + def foo2725(): Int = 2727 + def foo2726(): Int = 2728 + def foo2727(): Int = 2729 + def foo2728(): Int = 2730 + def foo2729(): Int = 2731 + def foo2730(): Int = 2732 + def foo2731(): Int = 2733 + def foo2732(): Int = 2734 + def foo2733(): Int = 2735 + def foo2734(): Int = 2736 + def foo2735(): Int = 2737 + def foo2736(): Int = 2738 + def foo2737(): Int = 2739 + def foo2738(): Int = 2740 + def foo2739(): Int = 2741 + def foo2740(): Int = 2742 + def foo2741(): Int = 2743 + def foo2742(): Int = 2744 + def foo2743(): Int = 2745 + def foo2744(): Int = 2746 + def foo2745(): Int = 2747 + def foo2746(): Int = 2748 + def foo2747(): Int = 2749 + def foo2748(): Int = 2750 + def foo2749(): Int = 2751 + def foo2750(): Int = 2752 + def foo2751(): Int = 2753 + def foo2752(): Int = 2754 + def foo2753(): Int = 2755 + def foo2754(): Int = 2756 + def foo2755(): Int = 2757 + def foo2756(): Int = 2758 + def foo2757(): Int = 2759 + def foo2758(): Int = 2760 + def foo2759(): Int = 2761 + def foo2760(): Int = 2762 + def foo2761(): Int = 2763 + def foo2762(): Int = 2764 + def foo2763(): Int = 2765 + def foo2764(): Int = 2766 + def foo2765(): Int = 2767 + def foo2766(): Int = 2768 + def foo2767(): Int = 2769 + def foo2768(): Int = 2770 + def foo2769(): Int = 2771 + def foo2770(): Int = 2772 + def foo2771(): Int = 2773 + def foo2772(): Int = 2774 + def foo2773(): Int = 2775 + def foo2774(): Int = 2776 + def foo2775(): Int = 2777 + def foo2776(): Int = 2778 + def foo2777(): Int = 2779 + def foo2778(): Int = 2780 + def foo2779(): Int = 2781 + def foo2780(): Int = 2782 + def foo2781(): Int = 2783 + def foo2782(): Int = 2784 + def foo2783(): Int = 2785 + def foo2784(): Int = 2786 + def foo2785(): Int = 2787 + def foo2786(): Int = 2788 + def foo2787(): Int = 2789 + def foo2788(): Int = 2790 + def foo2789(): Int = 2791 + def foo2790(): Int = 2792 + def foo2791(): Int = 2793 + def foo2792(): Int = 2794 + def foo2793(): Int = 2795 + def foo2794(): Int = 2796 + def foo2795(): Int = 2797 + def foo2796(): Int = 2798 + def foo2797(): Int = 2799 + def foo2798(): Int = 2800 + def foo2799(): Int = 2801 + def foo2800(): Int = 2802 + def foo2801(): Int = 2803 + def foo2802(): Int = 2804 + def foo2803(): Int = 2805 + def foo2804(): Int = 2806 + def foo2805(): Int = 2807 + def foo2806(): Int = 2808 + def foo2807(): Int = 2809 + def foo2808(): Int = 2810 + def foo2809(): Int = 2811 + def foo2810(): Int = 2812 + def foo2811(): Int = 2813 + def foo2812(): Int = 2814 + def foo2813(): Int = 2815 + def foo2814(): Int = 2816 + def foo2815(): Int = 2817 + def foo2816(): Int = 2818 + def foo2817(): Int = 2819 + def foo2818(): Int = 2820 + def foo2819(): Int = 2821 + def foo2820(): Int = 2822 + def foo2821(): Int = 2823 + def foo2822(): Int = 2824 + def foo2823(): Int = 2825 + def foo2824(): Int = 2826 + def foo2825(): Int = 2827 + def foo2826(): Int = 2828 + def foo2827(): Int = 2829 + def foo2828(): Int = 2830 + def foo2829(): Int = 2831 + def foo2830(): Int = 2832 + def foo2831(): Int = 2833 + def foo2832(): Int = 2834 + def foo2833(): Int = 2835 + def foo2834(): Int = 2836 + def foo2835(): Int = 2837 + def foo2836(): Int = 2838 + def foo2837(): Int = 2839 + def foo2838(): Int = 2840 + def foo2839(): Int = 2841 + def foo2840(): Int = 2842 + def foo2841(): Int = 2843 + def foo2842(): Int = 2844 + def foo2843(): Int = 2845 + def foo2844(): Int = 2846 + def foo2845(): Int = 2847 + def foo2846(): Int = 2848 + def foo2847(): Int = 2849 + def foo2848(): Int = 2850 + def foo2849(): Int = 2851 + def foo2850(): Int = 2852 + def foo2851(): Int = 2853 + def foo2852(): Int = 2854 + def foo2853(): Int = 2855 + def foo2854(): Int = 2856 + def foo2855(): Int = 2857 + def foo2856(): Int = 2858 + def foo2857(): Int = 2859 + def foo2858(): Int = 2860 + def foo2859(): Int = 2861 + def foo2860(): Int = 2862 + def foo2861(): Int = 2863 + def foo2862(): Int = 2864 + def foo2863(): Int = 2865 + def foo2864(): Int = 2866 + def foo2865(): Int = 2867 + def foo2866(): Int = 2868 + def foo2867(): Int = 2869 + def foo2868(): Int = 2870 + def foo2869(): Int = 2871 + def foo2870(): Int = 2872 + def foo2871(): Int = 2873 + def foo2872(): Int = 2874 + def foo2873(): Int = 2875 + def foo2874(): Int = 2876 + def foo2875(): Int = 2877 + def foo2876(): Int = 2878 + def foo2877(): Int = 2879 + def foo2878(): Int = 2880 + def foo2879(): Int = 2881 + def foo2880(): Int = 2882 + def foo2881(): Int = 2883 + def foo2882(): Int = 2884 + def foo2883(): Int = 2885 + def foo2884(): Int = 2886 + def foo2885(): Int = 2887 + def foo2886(): Int = 2888 + def foo2887(): Int = 2889 + def foo2888(): Int = 2890 + def foo2889(): Int = 2891 + def foo2890(): Int = 2892 + def foo2891(): Int = 2893 + def foo2892(): Int = 2894 + def foo2893(): Int = 2895 + def foo2894(): Int = 2896 + def foo2895(): Int = 2897 + def foo2896(): Int = 2898 + def foo2897(): Int = 2899 + def foo2898(): Int = 2900 + def foo2899(): Int = 2901 + def foo2900(): Int = 2902 + def foo2901(): Int = 2903 + def foo2902(): Int = 2904 + def foo2903(): Int = 2905 + def foo2904(): Int = 2906 + def foo2905(): Int = 2907 + def foo2906(): Int = 2908 + def foo2907(): Int = 2909 + def foo2908(): Int = 2910 + def foo2909(): Int = 2911 + def foo2910(): Int = 2912 + def foo2911(): Int = 2913 + def foo2912(): Int = 2914 + def foo2913(): Int = 2915 + def foo2914(): Int = 2916 + def foo2915(): Int = 2917 + def foo2916(): Int = 2918 + def foo2917(): Int = 2919 + def foo2918(): Int = 2920 + def foo2919(): Int = 2921 + def foo2920(): Int = 2922 + def foo2921(): Int = 2923 + def foo2922(): Int = 2924 + def foo2923(): Int = 2925 + def foo2924(): Int = 2926 + def foo2925(): Int = 2927 + def foo2926(): Int = 2928 + def foo2927(): Int = 2929 + def foo2928(): Int = 2930 + def foo2929(): Int = 2931 + def foo2930(): Int = 2932 + def foo2931(): Int = 2933 + def foo2932(): Int = 2934 + def foo2933(): Int = 2935 + def foo2934(): Int = 2936 + def foo2935(): Int = 2937 + def foo2936(): Int = 2938 + def foo2937(): Int = 2939 + def foo2938(): Int = 2940 + def foo2939(): Int = 2941 + def foo2940(): Int = 2942 + def foo2941(): Int = 2943 + def foo2942(): Int = 2944 + def foo2943(): Int = 2945 + def foo2944(): Int = 2946 + def foo2945(): Int = 2947 + def foo2946(): Int = 2948 + def foo2947(): Int = 2949 + def foo2948(): Int = 2950 + def foo2949(): Int = 2951 + def foo2950(): Int = 2952 + def foo2951(): Int = 2953 + def foo2952(): Int = 2954 + def foo2953(): Int = 2955 + def foo2954(): Int = 2956 + def foo2955(): Int = 2957 + def foo2956(): Int = 2958 + def foo2957(): Int = 2959 + def foo2958(): Int = 2960 + def foo2959(): Int = 2961 + def foo2960(): Int = 2962 + def foo2961(): Int = 2963 + def foo2962(): Int = 2964 + def foo2963(): Int = 2965 + def foo2964(): Int = 2966 + def foo2965(): Int = 2967 + def foo2966(): Int = 2968 + def foo2967(): Int = 2969 + def foo2968(): Int = 2970 + def foo2969(): Int = 2971 + def foo2970(): Int = 2972 + def foo2971(): Int = 2973 + def foo2972(): Int = 2974 + def foo2973(): Int = 2975 + def foo2974(): Int = 2976 + def foo2975(): Int = 2977 + def foo2976(): Int = 2978 + def foo2977(): Int = 2979 + def foo2978(): Int = 2980 + def foo2979(): Int = 2981 + def foo2980(): Int = 2982 + def foo2981(): Int = 2983 + def foo2982(): Int = 2984 + def foo2983(): Int = 2985 + def foo2984(): Int = 2986 + def foo2985(): Int = 2987 + def foo2986(): Int = 2988 + def foo2987(): Int = 2989 + def foo2988(): Int = 2990 + def foo2989(): Int = 2991 + def foo2990(): Int = 2992 + def foo2991(): Int = 2993 + def foo2992(): Int = 2994 + def foo2993(): Int = 2995 + def foo2994(): Int = 2996 + def foo2995(): Int = 2997 + def foo2996(): Int = 2998 + def foo2997(): Int = 2999 + def foo2998(): Int = 3000 + def foo2999(): Int = 3001 + def foo3000(): Int = 3002 + def foo3001(): Int = 3003 + def foo3002(): Int = 3004 + def foo3003(): Int = 3005 + def foo3004(): Int = 3006 + def foo3005(): Int = 3007 + def foo3006(): Int = 3008 + def foo3007(): Int = 3009 + def foo3008(): Int = 3010 + def foo3009(): Int = 3011 + def foo3010(): Int = 3012 + def foo3011(): Int = 3013 + def foo3012(): Int = 3014 + def foo3013(): Int = 3015 + def foo3014(): Int = 3016 + def foo3015(): Int = 3017 + def foo3016(): Int = 3018 + def foo3017(): Int = 3019 + def foo3018(): Int = 3020 + def foo3019(): Int = 3021 + def foo3020(): Int = 3022 + def foo3021(): Int = 3023 + def foo3022(): Int = 3024 + def foo3023(): Int = 3025 + def foo3024(): Int = 3026 + def foo3025(): Int = 3027 + def foo3026(): Int = 3028 + def foo3027(): Int = 3029 + def foo3028(): Int = 3030 + def foo3029(): Int = 3031 + def foo3030(): Int = 3032 + def foo3031(): Int = 3033 + def foo3032(): Int = 3034 + def foo3033(): Int = 3035 + def foo3034(): Int = 3036 + def foo3035(): Int = 3037 + def foo3036(): Int = 3038 + def foo3037(): Int = 3039 + def foo3038(): Int = 3040 + def foo3039(): Int = 3041 + def foo3040(): Int = 3042 + def foo3041(): Int = 3043 + def foo3042(): Int = 3044 + def foo3043(): Int = 3045 + def foo3044(): Int = 3046 + def foo3045(): Int = 3047 + def foo3046(): Int = 3048 + def foo3047(): Int = 3049 + def foo3048(): Int = 3050 + def foo3049(): Int = 3051 + def foo3050(): Int = 3052 + def foo3051(): Int = 3053 + def foo3052(): Int = 3054 + def foo3053(): Int = 3055 + def foo3054(): Int = 3056 + def foo3055(): Int = 3057 + def foo3056(): Int = 3058 + def foo3057(): Int = 3059 + def foo3058(): Int = 3060 + def foo3059(): Int = 3061 + def foo3060(): Int = 3062 + def foo3061(): Int = 3063 + def foo3062(): Int = 3064 + def foo3063(): Int = 3065 + def foo3064(): Int = 3066 + def foo3065(): Int = 3067 + def foo3066(): Int = 3068 + def foo3067(): Int = 3069 + def foo3068(): Int = 3070 + def foo3069(): Int = 3071 + def foo3070(): Int = 3072 + def foo3071(): Int = 3073 + def foo3072(): Int = 3074 + def foo3073(): Int = 3075 + def foo3074(): Int = 3076 + def foo3075(): Int = 3077 + def foo3076(): Int = 3078 + def foo3077(): Int = 3079 + def foo3078(): Int = 3080 + def foo3079(): Int = 3081 + def foo3080(): Int = 3082 + def foo3081(): Int = 3083 + def foo3082(): Int = 3084 + def foo3083(): Int = 3085 + def foo3084(): Int = 3086 + def foo3085(): Int = 3087 + def foo3086(): Int = 3088 + def foo3087(): Int = 3089 + def foo3088(): Int = 3090 + def foo3089(): Int = 3091 + def foo3090(): Int = 3092 + def foo3091(): Int = 3093 + def foo3092(): Int = 3094 + def foo3093(): Int = 3095 + def foo3094(): Int = 3096 + def foo3095(): Int = 3097 + def foo3096(): Int = 3098 + def foo3097(): Int = 3099 + def foo3098(): Int = 3100 + def foo3099(): Int = 3101 + def foo3100(): Int = 3102 + def foo3101(): Int = 3103 + def foo3102(): Int = 3104 + def foo3103(): Int = 3105 + def foo3104(): Int = 3106 + def foo3105(): Int = 3107 + def foo3106(): Int = 3108 + def foo3107(): Int = 3109 + def foo3108(): Int = 3110 + def foo3109(): Int = 3111 + def foo3110(): Int = 3112 + def foo3111(): Int = 3113 + def foo3112(): Int = 3114 + def foo3113(): Int = 3115 + def foo3114(): Int = 3116 + def foo3115(): Int = 3117 + def foo3116(): Int = 3118 + def foo3117(): Int = 3119 + def foo3118(): Int = 3120 + def foo3119(): Int = 3121 + def foo3120(): Int = 3122 + def foo3121(): Int = 3123 + def foo3122(): Int = 3124 + def foo3123(): Int = 3125 + def foo3124(): Int = 3126 + def foo3125(): Int = 3127 + def foo3126(): Int = 3128 + def foo3127(): Int = 3129 + def foo3128(): Int = 3130 + def foo3129(): Int = 3131 + def foo3130(): Int = 3132 + def foo3131(): Int = 3133 + def foo3132(): Int = 3134 + def foo3133(): Int = 3135 + def foo3134(): Int = 3136 + def foo3135(): Int = 3137 + def foo3136(): Int = 3138 + def foo3137(): Int = 3139 + def foo3138(): Int = 3140 + def foo3139(): Int = 3141 + def foo3140(): Int = 3142 + def foo3141(): Int = 3143 + def foo3142(): Int = 3144 + def foo3143(): Int = 3145 + def foo3144(): Int = 3146 + def foo3145(): Int = 3147 + def foo3146(): Int = 3148 + def foo3147(): Int = 3149 + def foo3148(): Int = 3150 + def foo3149(): Int = 3151 + def foo3150(): Int = 3152 + def foo3151(): Int = 3153 + def foo3152(): Int = 3154 + def foo3153(): Int = 3155 + def foo3154(): Int = 3156 + def foo3155(): Int = 3157 + def foo3156(): Int = 3158 + def foo3157(): Int = 3159 + def foo3158(): Int = 3160 + def foo3159(): Int = 3161 + def foo3160(): Int = 3162 + def foo3161(): Int = 3163 + def foo3162(): Int = 3164 + def foo3163(): Int = 3165 + def foo3164(): Int = 3166 + def foo3165(): Int = 3167 + def foo3166(): Int = 3168 + def foo3167(): Int = 3169 + def foo3168(): Int = 3170 + def foo3169(): Int = 3171 + def foo3170(): Int = 3172 + def foo3171(): Int = 3173 + def foo3172(): Int = 3174 + def foo3173(): Int = 3175 + def foo3174(): Int = 3176 + def foo3175(): Int = 3177 + def foo3176(): Int = 3178 + def foo3177(): Int = 3179 + def foo3178(): Int = 3180 + def foo3179(): Int = 3181 + def foo3180(): Int = 3182 + def foo3181(): Int = 3183 + def foo3182(): Int = 3184 + def foo3183(): Int = 3185 + def foo3184(): Int = 3186 + def foo3185(): Int = 3187 + def foo3186(): Int = 3188 + def foo3187(): Int = 3189 + def foo3188(): Int = 3190 + def foo3189(): Int = 3191 + def foo3190(): Int = 3192 + def foo3191(): Int = 3193 + def foo3192(): Int = 3194 + def foo3193(): Int = 3195 + def foo3194(): Int = 3196 + def foo3195(): Int = 3197 + def foo3196(): Int = 3198 + def foo3197(): Int = 3199 + def foo3198(): Int = 3200 + def foo3199(): Int = 3201 + def foo3200(): Int = 3202 + def foo3201(): Int = 3203 + def foo3202(): Int = 3204 + def foo3203(): Int = 3205 + def foo3204(): Int = 3206 + def foo3205(): Int = 3207 + def foo3206(): Int = 3208 + def foo3207(): Int = 3209 + def foo3208(): Int = 3210 + def foo3209(): Int = 3211 + def foo3210(): Int = 3212 + def foo3211(): Int = 3213 + def foo3212(): Int = 3214 + def foo3213(): Int = 3215 + def foo3214(): Int = 3216 + def foo3215(): Int = 3217 + def foo3216(): Int = 3218 + def foo3217(): Int = 3219 + def foo3218(): Int = 3220 + def foo3219(): Int = 3221 + def foo3220(): Int = 3222 + def foo3221(): Int = 3223 + def foo3222(): Int = 3224 + def foo3223(): Int = 3225 + def foo3224(): Int = 3226 + def foo3225(): Int = 3227 + def foo3226(): Int = 3228 + def foo3227(): Int = 3229 + def foo3228(): Int = 3230 + def foo3229(): Int = 3231 + def foo3230(): Int = 3232 + def foo3231(): Int = 3233 + def foo3232(): Int = 3234 + def foo3233(): Int = 3235 + def foo3234(): Int = 3236 + def foo3235(): Int = 3237 + def foo3236(): Int = 3238 + def foo3237(): Int = 3239 + def foo3238(): Int = 3240 + def foo3239(): Int = 3241 + def foo3240(): Int = 3242 + def foo3241(): Int = 3243 + def foo3242(): Int = 3244 + def foo3243(): Int = 3245 + def foo3244(): Int = 3246 + def foo3245(): Int = 3247 + def foo3246(): Int = 3248 + def foo3247(): Int = 3249 + def foo3248(): Int = 3250 + def foo3249(): Int = 3251 + def foo3250(): Int = 3252 + def foo3251(): Int = 3253 + def foo3252(): Int = 3254 + def foo3253(): Int = 3255 + def foo3254(): Int = 3256 + def foo3255(): Int = 3257 + def foo3256(): Int = 3258 + def foo3257(): Int = 3259 + def foo3258(): Int = 3260 + def foo3259(): Int = 3261 + def foo3260(): Int = 3262 + def foo3261(): Int = 3263 + def foo3262(): Int = 3264 + def foo3263(): Int = 3265 + def foo3264(): Int = 3266 + def foo3265(): Int = 3267 + def foo3266(): Int = 3268 + def foo3267(): Int = 3269 + def foo3268(): Int = 3270 + def foo3269(): Int = 3271 + def foo3270(): Int = 3272 + def foo3271(): Int = 3273 + def foo3272(): Int = 3274 + def foo3273(): Int = 3275 + def foo3274(): Int = 3276 + def foo3275(): Int = 3277 + def foo3276(): Int = 3278 + def foo3277(): Int = 3279 + def foo3278(): Int = 3280 + def foo3279(): Int = 3281 + def foo3280(): Int = 3282 + def foo3281(): Int = 3283 + def foo3282(): Int = 3284 + def foo3283(): Int = 3285 + def foo3284(): Int = 3286 + def foo3285(): Int = 3287 + def foo3286(): Int = 3288 + def foo3287(): Int = 3289 + def foo3288(): Int = 3290 + def foo3289(): Int = 3291 + def foo3290(): Int = 3292 + def foo3291(): Int = 3293 + def foo3292(): Int = 3294 + def foo3293(): Int = 3295 + def foo3294(): Int = 3296 + def foo3295(): Int = 3297 + def foo3296(): Int = 3298 + def foo3297(): Int = 3299 + def foo3298(): Int = 3300 + def foo3299(): Int = 3301 + def foo3300(): Int = 3302 + def foo3301(): Int = 3303 + def foo3302(): Int = 3304 + def foo3303(): Int = 3305 + def foo3304(): Int = 3306 + def foo3305(): Int = 3307 + def foo3306(): Int = 3308 + def foo3307(): Int = 3309 + def foo3308(): Int = 3310 + def foo3309(): Int = 3311 + def foo3310(): Int = 3312 + def foo3311(): Int = 3313 + def foo3312(): Int = 3314 + def foo3313(): Int = 3315 + def foo3314(): Int = 3316 + def foo3315(): Int = 3317 + def foo3316(): Int = 3318 + def foo3317(): Int = 3319 + def foo3318(): Int = 3320 + def foo3319(): Int = 3321 + def foo3320(): Int = 3322 + def foo3321(): Int = 3323 + def foo3322(): Int = 3324 + def foo3323(): Int = 3325 + def foo3324(): Int = 3326 + def foo3325(): Int = 3327 + def foo3326(): Int = 3328 + def foo3327(): Int = 3329 + def foo3328(): Int = 3330 + def foo3329(): Int = 3331 + def foo3330(): Int = 3332 + def foo3331(): Int = 3333 + def foo3332(): Int = 3334 + def foo3333(): Int = 3335 + def foo3334(): Int = 3336 + def foo3335(): Int = 3337 + def foo3336(): Int = 3338 + def foo3337(): Int = 3339 + def foo3338(): Int = 3340 + def foo3339(): Int = 3341 + def foo3340(): Int = 3342 + def foo3341(): Int = 3343 + def foo3342(): Int = 3344 + def foo3343(): Int = 3345 + def foo3344(): Int = 3346 + def foo3345(): Int = 3347 + def foo3346(): Int = 3348 + def foo3347(): Int = 3349 + def foo3348(): Int = 3350 + def foo3349(): Int = 3351 + def foo3350(): Int = 3352 + def foo3351(): Int = 3353 + def foo3352(): Int = 3354 + def foo3353(): Int = 3355 + def foo3354(): Int = 3356 + def foo3355(): Int = 3357 + def foo3356(): Int = 3358 + def foo3357(): Int = 3359 + def foo3358(): Int = 3360 + def foo3359(): Int = 3361 + def foo3360(): Int = 3362 + def foo3361(): Int = 3363 + def foo3362(): Int = 3364 + def foo3363(): Int = 3365 + def foo3364(): Int = 3366 + def foo3365(): Int = 3367 + def foo3366(): Int = 3368 + def foo3367(): Int = 3369 + def foo3368(): Int = 3370 + def foo3369(): Int = 3371 + def foo3370(): Int = 3372 + def foo3371(): Int = 3373 + def foo3372(): Int = 3374 + def foo3373(): Int = 3375 + def foo3374(): Int = 3376 + def foo3375(): Int = 3377 + def foo3376(): Int = 3378 + def foo3377(): Int = 3379 + def foo3378(): Int = 3380 + def foo3379(): Int = 3381 + def foo3380(): Int = 3382 + def foo3381(): Int = 3383 + def foo3382(): Int = 3384 + def foo3383(): Int = 3385 + def foo3384(): Int = 3386 + def foo3385(): Int = 3387 + def foo3386(): Int = 3388 + def foo3387(): Int = 3389 + def foo3388(): Int = 3390 + def foo3389(): Int = 3391 + def foo3390(): Int = 3392 + def foo3391(): Int = 3393 + def foo3392(): Int = 3394 + def foo3393(): Int = 3395 + def foo3394(): Int = 3396 + def foo3395(): Int = 3397 + def foo3396(): Int = 3398 + def foo3397(): Int = 3399 + def foo3398(): Int = 3400 + def foo3399(): Int = 3401 + def foo3400(): Int = 3402 + def foo3401(): Int = 3403 + def foo3402(): Int = 3404 + def foo3403(): Int = 3405 + def foo3404(): Int = 3406 + def foo3405(): Int = 3407 + def foo3406(): Int = 3408 + def foo3407(): Int = 3409 + def foo3408(): Int = 3410 + def foo3409(): Int = 3411 + def foo3410(): Int = 3412 + def foo3411(): Int = 3413 + def foo3412(): Int = 3414 + def foo3413(): Int = 3415 + def foo3414(): Int = 3416 + def foo3415(): Int = 3417 + def foo3416(): Int = 3418 + def foo3417(): Int = 3419 + def foo3418(): Int = 3420 + def foo3419(): Int = 3421 + def foo3420(): Int = 3422 + def foo3421(): Int = 3423 + def foo3422(): Int = 3424 + def foo3423(): Int = 3425 + def foo3424(): Int = 3426 + def foo3425(): Int = 3427 + def foo3426(): Int = 3428 + def foo3427(): Int = 3429 + def foo3428(): Int = 3430 + def foo3429(): Int = 3431 + def foo3430(): Int = 3432 + def foo3431(): Int = 3433 + def foo3432(): Int = 3434 + def foo3433(): Int = 3435 + def foo3434(): Int = 3436 + def foo3435(): Int = 3437 + def foo3436(): Int = 3438 + def foo3437(): Int = 3439 + def foo3438(): Int = 3440 + def foo3439(): Int = 3441 + def foo3440(): Int = 3442 + def foo3441(): Int = 3443 + def foo3442(): Int = 3444 + def foo3443(): Int = 3445 + def foo3444(): Int = 3446 + def foo3445(): Int = 3447 + def foo3446(): Int = 3448 + def foo3447(): Int = 3449 + def foo3448(): Int = 3450 + def foo3449(): Int = 3451 + def foo3450(): Int = 3452 + def foo3451(): Int = 3453 + def foo3452(): Int = 3454 + def foo3453(): Int = 3455 + def foo3454(): Int = 3456 + def foo3455(): Int = 3457 + def foo3456(): Int = 3458 + def foo3457(): Int = 3459 + def foo3458(): Int = 3460 + def foo3459(): Int = 3461 + def foo3460(): Int = 3462 + def foo3461(): Int = 3463 + def foo3462(): Int = 3464 + def foo3463(): Int = 3465 + def foo3464(): Int = 3466 + def foo3465(): Int = 3467 + def foo3466(): Int = 3468 + def foo3467(): Int = 3469 + def foo3468(): Int = 3470 + def foo3469(): Int = 3471 + def foo3470(): Int = 3472 + def foo3471(): Int = 3473 + def foo3472(): Int = 3474 + def foo3473(): Int = 3475 + def foo3474(): Int = 3476 + def foo3475(): Int = 3477 + def foo3476(): Int = 3478 + def foo3477(): Int = 3479 + def foo3478(): Int = 3480 + def foo3479(): Int = 3481 + def foo3480(): Int = 3482 + def foo3481(): Int = 3483 + def foo3482(): Int = 3484 + def foo3483(): Int = 3485 + def foo3484(): Int = 3486 + def foo3485(): Int = 3487 + def foo3486(): Int = 3488 + def foo3487(): Int = 3489 + def foo3488(): Int = 3490 + def foo3489(): Int = 3491 + def foo3490(): Int = 3492 + def foo3491(): Int = 3493 + def foo3492(): Int = 3494 + def foo3493(): Int = 3495 + def foo3494(): Int = 3496 + def foo3495(): Int = 3497 + def foo3496(): Int = 3498 + def foo3497(): Int = 3499 + def foo3498(): Int = 3500 + def foo3499(): Int = 3501 + def foo3500(): Int = 3502 +} diff --git a/test/files/t8449/Client.scala b/test/files/t8449/Client.scala new file mode 100644 index 0000000000..5d273f06b2 --- /dev/null +++ b/test/files/t8449/Client.scala @@ -0,0 +1,3 @@ +object Client { + def foo: Any = new Test().foo +} diff --git a/test/files/t8449/Test.java b/test/files/t8449/Test.java new file mode 100644 index 0000000000..ecb1711b24 --- /dev/null +++ b/test/files/t8449/Test.java @@ -0,0 +1,10 @@ +public class Test { + // Raw type over a Scala type constructor + public scala.Function1 foo() { return null; } + // scalac reported: + // % scalac-hash v2.11.2 -d /tmp sandbox/{Test.java,Client.scala} + // sandbox/Test.java:2: error: trait Function1 takes type parameters + // public scala.Function1 foo() { return null; } + // ^ + // one error found +} |