From 40e7cab7a22a8531bdd310bfb57fda51b798c690 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 11 May 2012 16:00:54 +0200 Subject: Fix SI-5009: case-class copy method now eta-expands over higher parameter lists. Example: Given case class C(a: Int)(b: Int) if you call (new C(1)(2)).copy(a = 10)), you get a function (f: Int => C) such that (f.apply(20)) yields a (new C(10)(20)). --- test/files/run/names-defaults.check | 2 +- test/files/run/names-defaults.scala | 4 ++-- test/files/run/t5009.check | 4 ++++ test/files/run/t5009.scala | 17 +++++++++++++++++ 4 files changed, 24 insertions(+), 3 deletions(-) create mode 100644 test/files/run/t5009.check create mode 100644 test/files/run/t5009.scala (limited to 'test/files/run') diff --git a/test/files/run/names-defaults.check b/test/files/run/names-defaults.check index 5656d1a276..f253de71d6 100644 --- a/test/files/run/names-defaults.check +++ b/test/files/run/names-defaults.check @@ -92,7 +92,7 @@ test5 test5 5 10: 2 -slkdfj1 +slkdfj2 1 lskfdjlk 11 diff --git a/test/files/run/names-defaults.scala b/test/files/run/names-defaults.scala index e1bc7cbf59..220414f02a 100644 --- a/test/files/run/names-defaults.scala +++ b/test/files/run/names-defaults.scala @@ -176,7 +176,7 @@ object Test extends App { println(Fact2()("jyp")) println(Fact2(x = 1)()) - println(Fact2(10)().copy(y = "blabla")()) + println(Fact2(10)().copy(y = "blabla")(3)) // assignment to var <-> named argument @@ -195,7 +195,7 @@ object Test extends App { // dependent types and copy method val a11 = new A2 val b11 = a11.B2(new a11.C2)(1) - println(b11.copy()()) + println(b11.copy()(2)) diff --git a/test/files/run/t5009.check b/test/files/run/t5009.check new file mode 100644 index 0000000000..cc9df54b34 --- /dev/null +++ b/test/files/run/t5009.check @@ -0,0 +1,4 @@ +C(1,true) +10 +C(7283,20) +100 diff --git a/test/files/run/t5009.scala b/test/files/run/t5009.scala new file mode 100644 index 0000000000..b4fe1bc894 --- /dev/null +++ b/test/files/run/t5009.scala @@ -0,0 +1,17 @@ +object Test extends App { + + case class C[T, U <: String, O >: Object](x: Int, y: T)(z: U, b: Boolean)(s: O, val l: Int) + + val c = C(1, true)("dlkfj", true)("dlkfjlk", 10) + println(c) + println(c.l) + + val f1a = c.copy(y = 20, x = 7283) + + val f1b = c.copy[Int, String, Object](y = 20, x = 7283) + val f2b = f1b("lkdjen", false) + val res = f2b(new Object, 100) + println(res) + println(res.l) + +} -- cgit v1.2.3 From f707141863799c801df6bdd3bbbc28a01c15bbbd Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sat, 12 May 2012 09:05:50 +0200 Subject: Test case closes SI-5407 It still breaks as described in the ticket under -Xoldpatmat. --- test/files/run/t5407.check | 2 ++ test/files/run/t5407.scala | 17 +++++++++++++++++ 2 files changed, 19 insertions(+) create mode 100644 test/files/run/t5407.check create mode 100644 test/files/run/t5407.scala (limited to 'test/files/run') diff --git a/test/files/run/t5407.check b/test/files/run/t5407.check new file mode 100644 index 0000000000..51993f072d --- /dev/null +++ b/test/files/run/t5407.check @@ -0,0 +1,2 @@ +2 +2 diff --git a/test/files/run/t5407.scala b/test/files/run/t5407.scala new file mode 100644 index 0000000000..35a8ec6a45 --- /dev/null +++ b/test/files/run/t5407.scala @@ -0,0 +1,17 @@ +case class Foo(private val x: Int, y: Option[Int], z: Boolean) + +object Test extends App { + def foo(x: Foo) = x match { + case Foo(x, Some(y), z) => y + case Foo(x, y, z) => 0 + } + val x = Foo(1, Some(2), false) + println(foo(x)) + + + def bar(x: Foo) = x match { + case Foo(x, Some(y), z) => y + case Foo(x, None, z) => 0 + } + println(bar(x)) +} \ No newline at end of file -- cgit v1.2.3 From 3bbf6328dc325363dedfbc6068e7ae3fbbc10cdb Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sat, 12 May 2012 13:21:58 +0200 Subject: A REPL pattern matching crasher that crashes no more. Not due to virtpatmat, mind you; it passes with -Xoldpatmat. Closes SI-4025. --- test/files/run/t4025.check | 19 +++++++++++++++++++ test/files/run/t4025.scala | 12 ++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 test/files/run/t4025.check create mode 100644 test/files/run/t4025.scala (limited to 'test/files/run') diff --git a/test/files/run/t4025.check b/test/files/run/t4025.check new file mode 100644 index 0000000000..6715003cb6 --- /dev/null +++ b/test/files/run/t4025.check @@ -0,0 +1,19 @@ +Type in expressions to have them evaluated. +Type :help for more information. + +scala> + +scala> class Color(val red: Int) +defined class Color + +scala> + +scala> case class Red(r:Int) extends Color(r) +defined class Red + +scala> + +scala> def f(c: Any) = c match { case Red(_) => () } +f: (c: Any)Unit + +scala> diff --git a/test/files/run/t4025.scala b/test/files/run/t4025.scala new file mode 100644 index 0000000000..5db0093970 --- /dev/null +++ b/test/files/run/t4025.scala @@ -0,0 +1,12 @@ +import scala.tools.nsc.Settings +import scala.tools.partest.ReplTest + +object Test extends ReplTest { + def code = """ +class Color(val red: Int) + +case class Red(r:Int) extends Color(r) + +def f(c: Any) = c match { case Red(_) => () } +""" +} -- cgit v1.2.3 From a9a2fd7c479eb8d68bf7e58cd0f6084a2106ca7d Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Sat, 12 May 2012 07:30:19 -0700 Subject: Clutch modification to tree printing. Don't print trees under -Xprint:all if they're identical to the tree printed at the previous phase. It only works for a single compilation unit but that is a huge step forward for us debuggers. For instance this file: trait Foo { def f = 5 } used to produce 332 lines of output and now produces 92, with zero loss of information. It ends with: [[syntax trees at end of cleanup]] // a.scala: tree is unchanged since mixin [[syntax trees at end of icode]] // a.scala: tree is unchanged since mixin [[syntax trees at end of inliner]] // a.scala: tree is unchanged since mixin [[syntax trees at end of inlineExceptionHandlers]] // a.scala: tree is unchanged since mixin [[syntax trees at end of closelim]] // a.scala: tree is unchanged since mixin [[syntax trees at end of dce]] // a.scala: tree is unchanged since mixin [[syntax trees at end of jvm]] // a.scala: tree is unchanged since mixin --- src/compiler/scala/tools/nsc/Global.scala | 27 +++++++++++++++++++++++++-- test/files/run/t5527.check | 2 +- test/files/specialized/SI-5005.check | 2 +- 3 files changed, 27 insertions(+), 4 deletions(-) (limited to 'test/files/run') diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index de270a76f1..49a644ba3a 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -130,7 +130,28 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb object nodePrinters extends { val global: Global.this.type = Global.this } with NodePrinters { + var lastPrintedPhase: Phase = NoPhase + var lastPrintedSource: String = "" infolevel = InfoLevel.Verbose + + def showUnit(unit: CompilationUnit) { + print(" // " + unit.source) + if (unit.body == null) println(": tree is null") + else { + val source = util.stringFromWriter(w => newTreePrinter(w) print unit.body) + + // treePrinter show unit.body + if (lastPrintedSource == source) + println(": tree is unchanged since " + lastPrintedPhase) + else { + lastPrintedPhase = phase.prev // since we're running inside "afterPhase" + lastPrintedSource = source + println("") + println(source) + println("") + } + } + } } def withInfoLevel[T](infolevel: nodePrinters.InfoLevel.Value)(op: => T) = { @@ -1588,8 +1609,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb } // class Run def printAllUnits() { - print("[[syntax trees at end of " + phase + "]]") - afterPhase(phase) { currentRun.units foreach (treePrinter.print(_)) } + print("[[syntax trees at end of %25s]]".format(phase)) + afterPhase(phase)(currentRun.units foreach { unit => + nodePrinters showUnit unit + }) } /** We resolve the class/object ambiguity by passing a type/term name. diff --git a/test/files/run/t5527.check b/test/files/run/t5527.check index bb13928fd8..1518168c51 100644 --- a/test/files/run/t5527.check +++ b/test/files/run/t5527.check @@ -1,4 +1,4 @@ -[[syntax trees at end of parser]]// Scala source: newSource1 +[[syntax trees at end of parser]] // newSource1 package { object UselessComments extends scala.AnyRef { def () = { diff --git a/test/files/specialized/SI-5005.check b/test/files/specialized/SI-5005.check index 9fc63a2b1d..81e8342dad 100644 --- a/test/files/specialized/SI-5005.check +++ b/test/files/specialized/SI-5005.check @@ -1,4 +1,4 @@ -[[syntax trees at end of specialize]]// Scala source: newSource1 +[[syntax trees at end of specialize]] // newSource1 package { class C2[@specialized(scala.Boolean) U >: Nothing <: Any] extends Object { def (): C2[U] = { -- cgit v1.2.3 From f1d81c9b9b300b2f526c03a27600e6fe481fc7c6 Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Sat, 12 May 2012 08:03:08 -0700 Subject: Test case closes SI-5037. --- test/files/run/t5037.check | 2 ++ test/files/run/t5037.scala | 18 ++++++++++++++++++ 2 files changed, 20 insertions(+) create mode 100644 test/files/run/t5037.check create mode 100644 test/files/run/t5037.scala (limited to 'test/files/run') diff --git a/test/files/run/t5037.check b/test/files/run/t5037.check new file mode 100644 index 0000000000..da29283aaa --- /dev/null +++ b/test/files/run/t5037.check @@ -0,0 +1,2 @@ +true +false diff --git a/test/files/run/t5037.scala b/test/files/run/t5037.scala new file mode 100644 index 0000000000..7b1fce7a82 --- /dev/null +++ b/test/files/run/t5037.scala @@ -0,0 +1,18 @@ +object Test { + def main(args: Array[String]) { + val t = new Test + t.inner.foo() + } +} + +class Test { + class Inner { + def foo() { + println(bar) + bar = false + println(bar) + } + } + val inner = new Inner + private[this] final var bar = true +} -- cgit v1.2.3