From bd54fd04dada033836d2b9113e40b9485a52522a Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Wed, 24 Aug 2016 13:38:40 +0200 Subject: Fix #1468: Add type parameter support for scala.Dynamic --- tests/run/dynamicDynamicTests.scala | 41 +++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) (limited to 'tests/run') diff --git a/tests/run/dynamicDynamicTests.scala b/tests/run/dynamicDynamicTests.scala index 3f8da8298..05b878f1c 100644 --- a/tests/run/dynamicDynamicTests.scala +++ b/tests/run/dynamicDynamicTests.scala @@ -23,7 +23,16 @@ class Baz extends scala.Dynamic { def updateDynamic(name: String)(value: String): String = "updateDynamic(" + name + ")(" + value + ")" } +class Qux extends scala.Dynamic { + def selectDynamic[T](name: String): String = "selectDynamic(" + name + ")" + def applyDynamic[T](name: String)(args: String*): String = "applyDynamic(" + name + ")" + args.mkString("(", ", ", ")") + def applyDynamicNamed[T](name: String)(args: (String, Any)*): String = "applyDynamicNamed(" + name + ")" + args.mkString("(", ", ", ")") + def updateDynamic[T](name: String)(value: T): String = "updateDynamic(" + name + ")(" + value + ")" +} + object Test { + val qux = new Qux + implicit class StringUpdater(str: String) { def update(name: String, v: String) = s"$str.update(" + name + ", " + v + ")" } @@ -42,6 +51,7 @@ object Test { runFooTests2() runBarTests() runBazTests() + runQuxTests() assert(!failed) } @@ -161,4 +171,35 @@ object Test { assertEquals("selectDynamic(bazSelectUpdate).update(7, value)", baz.bazSelectUpdate(7) = "value") assertEquals("selectDynamic(bazSelectUpdate).update(7, 10)", baz.bazSelectUpdate(7) = 10) } + + /** Test correct lifting of type parameters */ + def runQuxTests() = { + implicit def intToString(n: Int): String = n.toString + + val qux = new Qux + + assertEquals("selectDynamic(quxSelect)", qux.quxSelect) + assertEquals("selectDynamic(quxSelect)", qux.quxSelect[Int]) + + assertEquals("applyDynamic(quxApply)()", qux.quxApply()) + assertEquals("applyDynamic(quxApply)()", qux.quxApply[Int]()) + assertEquals("applyDynamic(quxApply)(1)", qux.quxApply(1)) + assertEquals("applyDynamic(quxApply)(1)", qux.quxApply[Int](1)) + assertEquals("applyDynamic(quxApply)(1, 2, 3)", qux.quxApply(1, 2, 3)) + assertEquals("applyDynamic(quxApply)(1, 2, 3)", qux.quxApply[Int](1, 2, 3)) + assertEquals("applyDynamic(quxApply)(1, 2, a)", qux.quxApply(1, 2, "a")) + assertEquals("applyDynamic(quxApply)(1, 2, a)", qux.quxApply[Int](1, 2, "a")) + + assertEquals("applyDynamicNamed(quxApplyNamed)((a,1))", qux.quxApplyNamed(a = 1)) + assertEquals("applyDynamicNamed(quxApplyNamed)((a,1))", qux.quxApplyNamed[Int](a = 1)) + assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (b,2))", qux.quxApplyNamed(a = 1, b = "2")) + assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (b,2))", qux.quxApplyNamed[Int](a = 1, b = "2")) + assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (,abc))", qux.quxApplyNamed(a = 1, "abc")) + assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (,abc))", qux.quxApplyNamed[Int](a = 1, "abc")) + + assertEquals("updateDynamic(quxUpdate)(abc)", qux.quxUpdate = "abc") + + assertEquals("selectDynamic(quxSelectUpdate).update(key, value)", qux.quxSelectUpdate("key") = "value") + assertEquals("selectDynamic(quxSelectUpdate).update(key, value)", qux.quxSelectUpdate[Int]("key") = "value") + } } -- cgit v1.2.3 From ba65dd99eccdad9d67ea1067c0ea0c24c794455b Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Wed, 24 Aug 2016 15:04:51 +0200 Subject: Fix #1470: Fix dynamic selection in presence of inaccessible members. --- src/dotty/tools/dotc/typer/TypeAssigner.scala | 5 +++-- tests/pending/run/t5040.check | 1 - tests/pending/run/t5040.flags | 1 - tests/pending/run/t5040.scala | 11 ----------- tests/run/t5040.check | 1 + tests/run/t5040.flags | 1 + tests/run/t5040.scala | 12 ++++++++++++ 7 files changed, 17 insertions(+), 15 deletions(-) delete mode 100644 tests/pending/run/t5040.check delete mode 100644 tests/pending/run/t5040.flags delete mode 100644 tests/pending/run/t5040.scala create mode 100644 tests/run/t5040.check create mode 100644 tests/run/t5040.flags create mode 100644 tests/run/t5040.scala (limited to 'tests/run') diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala index 36404a68f..6f401f4f8 100644 --- a/src/dotty/tools/dotc/typer/TypeAssigner.scala +++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala @@ -203,8 +203,9 @@ trait TypeAssigner { */ def selectionType(site: Type, name: Name, pos: Position)(implicit ctx: Context): Type = { val mbr = site.member(name) - if (reallyExists(mbr)) site.select(name, mbr) - else if (site.derivesFrom(defn.DynamicClass) && !Dynamic.isDynamicMethod(name)) { + lazy val canBeDynamicMethod = site.derivesFrom(defn.DynamicClass) && !Dynamic.isDynamicMethod(name) + if (reallyExists(mbr) && (mbr.accessibleFrom(site).exists || !canBeDynamicMethod)) site.select(name, mbr) + else if (canBeDynamicMethod) { TryDynamicCallType } else { if (!site.isErroneous) { diff --git a/tests/pending/run/t5040.check b/tests/pending/run/t5040.check deleted file mode 100644 index 3f7b5908a..000000000 --- a/tests/pending/run/t5040.check +++ /dev/null @@ -1 +0,0 @@ -applyDynamic diff --git a/tests/pending/run/t5040.flags b/tests/pending/run/t5040.flags deleted file mode 100644 index 1141f9750..000000000 --- a/tests/pending/run/t5040.flags +++ /dev/null @@ -1 +0,0 @@ --language:dynamics diff --git a/tests/pending/run/t5040.scala b/tests/pending/run/t5040.scala deleted file mode 100644 index 6813c1b27..000000000 --- a/tests/pending/run/t5040.scala +++ /dev/null @@ -1,11 +0,0 @@ -abstract class Prova2 extends Dynamic { - def applyDynamic(m: String)(): Unit - private def privateMethod() = println("private method") -} - -object Test extends dotty.runtime.LegacyApp { - val prova= new Prova2 { - def applyDynamic(m: String)() = println("applyDynamic") - } - prova.privateMethod() -} diff --git a/tests/run/t5040.check b/tests/run/t5040.check new file mode 100644 index 000000000..3f7b5908a --- /dev/null +++ b/tests/run/t5040.check @@ -0,0 +1 @@ +applyDynamic diff --git a/tests/run/t5040.flags b/tests/run/t5040.flags new file mode 100644 index 000000000..1141f9750 --- /dev/null +++ b/tests/run/t5040.flags @@ -0,0 +1 @@ +-language:dynamics diff --git a/tests/run/t5040.scala b/tests/run/t5040.scala new file mode 100644 index 000000000..58d054412 --- /dev/null +++ b/tests/run/t5040.scala @@ -0,0 +1,12 @@ +import scala.language.dynamics // originaly used the flag -language:dynamics in t5040.flags, .flags are currently ignored +abstract class Prova2 extends Dynamic { + def applyDynamic(m: String)(): Unit + private def privateMethod() = println("private method") +} + +object Test extends dotty.runtime.LegacyApp { + val prova= new Prova2 { + def applyDynamic(m: String)() = println("applyDynamic") + } + prova.privateMethod() +} -- cgit v1.2.3 From 390a44cdd0b3f43df0969368f62314d78a25c699 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Thu, 25 Aug 2016 09:57:18 +0200 Subject: Fix #1474: Fix applies to applyDynamic. --- src/dotty/tools/dotc/typer/Applications.scala | 16 ++++--- tests/pending/run/applydynamic_sip.check | 29 ------------ tests/pending/run/applydynamic_sip.flags | 2 - tests/pending/run/applydynamic_sip.scala | 66 -------------------------- tests/pending/run/t6353.check | 1 - tests/pending/run/t6353.scala | 12 ----- tests/run/applydynamic_sip.check | 29 ++++++++++++ tests/run/applydynamic_sip.flags | 2 + tests/run/applydynamic_sip.scala | 67 +++++++++++++++++++++++++++ tests/run/t6353.check | 1 + tests/run/t6353.scala | 12 +++++ 11 files changed, 120 insertions(+), 117 deletions(-) delete mode 100644 tests/pending/run/applydynamic_sip.check delete mode 100644 tests/pending/run/applydynamic_sip.flags delete mode 100644 tests/pending/run/applydynamic_sip.scala delete mode 100644 tests/pending/run/t6353.check delete mode 100644 tests/pending/run/t6353.scala create mode 100644 tests/run/applydynamic_sip.check create mode 100644 tests/run/applydynamic_sip.flags create mode 100644 tests/run/applydynamic_sip.scala create mode 100644 tests/run/t6353.check create mode 100644 tests/run/t6353.scala (limited to 'tests/run') diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala index 318f2f8ff..52e80930e 100644 --- a/src/dotty/tools/dotc/typer/Applications.scala +++ b/src/dotty/tools/dotc/typer/Applications.scala @@ -592,13 +592,15 @@ trait Applications extends Compatibility { self: Typer with Dynamic => fun1.tpe match { case ErrorType => tree.withType(ErrorType) case TryDynamicCallType => - tree match { - case Apply(Select(qual, name), args) if !isDynamicMethod(name) => - typedDynamicApply(qual, name, None, args, pt)(tree) - case Apply(TypeApply(Select(qual, name), targs), args) if !isDynamicMethod(name) => - typedDynamicApply(qual, name, Some(targs), args, pt)(tree) - case _ => - handleUnexpectedFunType(tree, fun1) + tree.fun match { + case Select(qual, name) if !isDynamicMethod(name) => + typedDynamicApply(qual, name, None, tree.args, pt)(tree) + case TypeApply(Select(qual, name), targs) if !isDynamicMethod(name) => + typedDynamicApply(qual, name, Some(targs), tree.args, pt)(tree) + case TypeApply(fun, targs) => + typedDynamicApply(fun, nme.apply, Some(targs), tree.args, pt)(tree) + case fun => + typedDynamicApply(fun, nme.apply, None, tree.args, pt)(tree) } case _ => tryEither { diff --git a/tests/pending/run/applydynamic_sip.check b/tests/pending/run/applydynamic_sip.check deleted file mode 100644 index 6d04dc452..000000000 --- a/tests/pending/run/applydynamic_sip.check +++ /dev/null @@ -1,29 +0,0 @@ -qual.applyDynamic(sel)() -qual.applyDynamic(sel)(a) -qual.applyDynamic(sel)(a) -.apply(a2) -qual.applyDynamic(sel)(a) -qual.applyDynamic(sel)(a) -.apply(a2) -qual.applyDynamicNamed(sel)((arg,a)) -qual.applyDynamicNamed(sel)((arg,a)) -qual.applyDynamicNamed(sel)((,a), (arg2,a2)) -qual.updateDynamic(sel)(expr) -qual.selectDynamic(sel) -qual.selectDynamic(sel) -qual.selectDynamic(sel) -.update(1, expr) -qual.selectDynamic(sel) -.update(expr) -qual.selectDynamic(sel) -.apply(1) -qual.selectDynamic(sel) -.apply -.update(1, 1) -qual.applyDynamic(apply)(a) -qual.applyDynamic(apply)(a) -qual.applyDynamic(apply)(a) -qual.applyDynamic(apply)(a) -qual.applyDynamicNamed(apply)((arg,a)) -qual.applyDynamicNamed(apply)((,a), (arg2,a2)) -qual.applyDynamic(update)(a, a2) diff --git a/tests/pending/run/applydynamic_sip.flags b/tests/pending/run/applydynamic_sip.flags deleted file mode 100644 index ba6d37305..000000000 --- a/tests/pending/run/applydynamic_sip.flags +++ /dev/null @@ -1,2 +0,0 @@ --Yrangepos:false --language:dynamics diff --git a/tests/pending/run/applydynamic_sip.scala b/tests/pending/run/applydynamic_sip.scala deleted file mode 100644 index a163ab960..000000000 --- a/tests/pending/run/applydynamic_sip.scala +++ /dev/null @@ -1,66 +0,0 @@ -object Test extends dotty.runtime.LegacyApp { - object stubUpdate { - def update(as: Any*) = println(".update"+as.toList.mkString("(",", ", ")")) - } - - object stub { - def apply = {println(".apply"); stubUpdate} - def apply(as: Any*) = println(".apply"+as.toList.mkString("(",", ", ")")) - def update(as: Any*) = println(".update"+as.toList.mkString("(",", ", ")")) - } - class MyDynamic extends Dynamic { - def applyDynamic[T](n: String)(as: Any*) = {println("qual.applyDynamic("+ n +")"+ as.toList.mkString("(",", ", ")")); stub} - def applyDynamicNamed[T](n: String)(as: (String, Any)*) = {println("qual.applyDynamicNamed("+ n +")"+ as.toList.mkString("(",", ", ")")); stub} - def selectDynamic[T](n: String) = {println("qual.selectDynamic("+ n +")"); stub} - def updateDynamic(n: String)(x: Any): Unit = {println("qual.updateDynamic("+ n +")("+ x +")")} - } - val qual = new MyDynamic - val expr = "expr" - val a = "a" - val a2 = "a2" - type T = String - - // If qual.sel is followed by a potential type argument list [Ts] and an argument list (arg1, …, argn) where none of the arguments argi are named: - // qual.applyDynamic(“sel”)(arg1, …, argn) - qual.sel() - qual.sel(a) - // qual.sel(a, a2: _*) -- should not accept varargs? - qual.sel(a)(a2) - qual.sel[T](a) - qual.sel[T](a)(a2) - - // If qual.sel is followed by a potential type argument list [Ts] - // and a non-empty named argument list (x1 = arg1, …, xn = argn) where some name prefixes xi = might be missing: - // qual.applyDynamicNamed(“sel”)(xs1 -> arg1, …, xsn -> argn) - qual.sel(arg = a) - qual.sel[T](arg = a) - qual.sel(a, arg2 = "a2") - // qual.sel(a)(a2, arg2 = "a2") - // qual.sel[T](a)(a2, arg2 = "a2") - // qual.sel(arg = a, a2: _*) - // qual.sel(arg, arg2 = "a2", a2: _*) - - // If qual.sel appears immediately on the left-hand side of an assigment - // qual.updateDynamic(“sel”)(expr) - qual.sel = expr - - // If qual.sel, possibly applied to type arguments, but is - // not applied to explicit value arguments, - // nor immediately followed by an assignment operator: - // qual.selectDynamic[Ts](“sel”) - qual.sel - qual.sel[T] - - qual.sel(1) = expr // parser turns this into qual.sel.update(1, expr) - qual.sel() = expr // parser turns this into qual.sel.update(expr) - qual.sel.apply(1) - qual.sel.apply(1) = 1 - - qual.apply(a) - qual.apply[String](a) - qual(a) - qual[String](a) - qual[T](arg = a) - qual(a, arg2 = "a2") - qual(a) = a2 -} diff --git a/tests/pending/run/t6353.check b/tests/pending/run/t6353.check deleted file mode 100644 index 5676bed24..000000000 --- a/tests/pending/run/t6353.check +++ /dev/null @@ -1 +0,0 @@ -applyDynamic(apply)(9) diff --git a/tests/pending/run/t6353.scala b/tests/pending/run/t6353.scala deleted file mode 100644 index 7077eaeda..000000000 --- a/tests/pending/run/t6353.scala +++ /dev/null @@ -1,12 +0,0 @@ -import language.dynamics - -object Test extends dotty.runtime.LegacyApp { - val x = new X(3) - val y = x(9) - class X(i: Int) extends Dynamic { - def applyDynamic(name: String)(in: Int): Int = { - println(s"applyDynamic($name)($in)") - i + in - } - } -} diff --git a/tests/run/applydynamic_sip.check b/tests/run/applydynamic_sip.check new file mode 100644 index 000000000..6d04dc452 --- /dev/null +++ b/tests/run/applydynamic_sip.check @@ -0,0 +1,29 @@ +qual.applyDynamic(sel)() +qual.applyDynamic(sel)(a) +qual.applyDynamic(sel)(a) +.apply(a2) +qual.applyDynamic(sel)(a) +qual.applyDynamic(sel)(a) +.apply(a2) +qual.applyDynamicNamed(sel)((arg,a)) +qual.applyDynamicNamed(sel)((arg,a)) +qual.applyDynamicNamed(sel)((,a), (arg2,a2)) +qual.updateDynamic(sel)(expr) +qual.selectDynamic(sel) +qual.selectDynamic(sel) +qual.selectDynamic(sel) +.update(1, expr) +qual.selectDynamic(sel) +.update(expr) +qual.selectDynamic(sel) +.apply(1) +qual.selectDynamic(sel) +.apply +.update(1, 1) +qual.applyDynamic(apply)(a) +qual.applyDynamic(apply)(a) +qual.applyDynamic(apply)(a) +qual.applyDynamic(apply)(a) +qual.applyDynamicNamed(apply)((arg,a)) +qual.applyDynamicNamed(apply)((,a), (arg2,a2)) +qual.applyDynamic(update)(a, a2) diff --git a/tests/run/applydynamic_sip.flags b/tests/run/applydynamic_sip.flags new file mode 100644 index 000000000..ba6d37305 --- /dev/null +++ b/tests/run/applydynamic_sip.flags @@ -0,0 +1,2 @@ +-Yrangepos:false +-language:dynamics diff --git a/tests/run/applydynamic_sip.scala b/tests/run/applydynamic_sip.scala new file mode 100644 index 000000000..7f81a644a --- /dev/null +++ b/tests/run/applydynamic_sip.scala @@ -0,0 +1,67 @@ +import scala.language.dynamics +object Test extends dotty.runtime.LegacyApp { + object stubUpdate { + def update(as: Any*) = println(".update"+as.toList.mkString("(",", ", ")")) + } + + object stub { + def apply = {println(".apply"); stubUpdate} + def apply(as: Any*) = println(".apply"+as.toList.mkString("(",", ", ")")) + def update(as: Any*) = println(".update"+as.toList.mkString("(",", ", ")")) + } + class MyDynamic extends Dynamic { + def applyDynamic[T](n: String)(as: Any*) = {println("qual.applyDynamic("+ n +")"+ as.toList.mkString("(",", ", ")")); stub} + def applyDynamicNamed[T](n: String)(as: (String, Any)*) = {println("qual.applyDynamicNamed("+ n +")"+ as.toList.mkString("(",", ", ")")); stub} + def selectDynamic[T](n: String) = {println("qual.selectDynamic("+ n +")"); stub} + def updateDynamic(n: String)(x: Any): Unit = {println("qual.updateDynamic("+ n +")("+ x +")")} + } + val qual = new MyDynamic + val expr = "expr" + val a = "a" + val a2 = "a2" + type T = String + + // If qual.sel is followed by a potential type argument list [Ts] and an argument list (arg1, …, argn) where none of the arguments argi are named: + // qual.applyDynamic(“sel”)(arg1, …, argn) + qual.sel() + qual.sel(a) + // qual.sel(a, a2: _*) -- should not accept varargs? + qual.sel(a)(a2) + qual.sel[T](a) + qual.sel[T](a)(a2) + + // If qual.sel is followed by a potential type argument list [Ts] + // and a non-empty named argument list (x1 = arg1, …, xn = argn) where some name prefixes xi = might be missing: + // qual.applyDynamicNamed(“sel”)(xs1 -> arg1, …, xsn -> argn) + qual.sel(arg = a) + qual.sel[T](arg = a) + qual.sel(a, arg2 = "a2") + // qual.sel(a)(a2, arg2 = "a2") + // qual.sel[T](a)(a2, arg2 = "a2") + // qual.sel(arg = a, a2: _*) + // qual.sel(arg, arg2 = "a2", a2: _*) + + // If qual.sel appears immediately on the left-hand side of an assigment + // qual.updateDynamic(“sel”)(expr) + qual.sel = expr + + // If qual.sel, possibly applied to type arguments, but is + // not applied to explicit value arguments, + // nor immediately followed by an assignment operator: + // qual.selectDynamic[Ts](“sel”) + qual.sel + qual.sel[T] + + qual.sel(1) = expr // parser turns this into qual.sel.update(1, expr) + qual.sel() = expr // parser turns this into qual.sel.update(expr) + qual.sel.apply(1) + qual.sel.apply(1) = 1 + + qual.apply(a) + qual.apply[String](a) + qual(a) + qual[String](a) + qual[T](arg = a) + qual(a, arg2 = "a2") + qual(a) = a2 +} diff --git a/tests/run/t6353.check b/tests/run/t6353.check new file mode 100644 index 000000000..5676bed24 --- /dev/null +++ b/tests/run/t6353.check @@ -0,0 +1 @@ +applyDynamic(apply)(9) diff --git a/tests/run/t6353.scala b/tests/run/t6353.scala new file mode 100644 index 000000000..7077eaeda --- /dev/null +++ b/tests/run/t6353.scala @@ -0,0 +1,12 @@ +import language.dynamics + +object Test extends dotty.runtime.LegacyApp { + val x = new X(3) + val y = x(9) + class X(i: Int) extends Dynamic { + def applyDynamic(name: String)(in: Int): Int = { + println(s"applyDynamic($name)($in)") + i + in + } + } +} -- cgit v1.2.3 From f001eef2213bc5b1affde992aae7780c15d5fd44 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Fri, 26 Aug 2016 11:20:56 +0200 Subject: Enable scala.Dynamic pending/untried tests. --- tests/neg/applydynamic_sip.check | 52 +++++++++++++++++++++++ tests/neg/applydynamic_sip.flags | 1 + tests/neg/applydynamic_sip.scala | 36 ++++++++++++++++ tests/neg/t6355b.check | 11 +++++ tests/neg/t6355b.scala | 17 ++++++++ tests/neg/t6920.check | 6 +++ tests/neg/t6920.scala | 10 +++++ tests/neg/t8006.check | 6 +++ tests/neg/t8006.scala | 8 ++++ tests/pending/run/dynamic-anyval.check | 4 -- tests/pending/run/dynamic-anyval.scala | 22 ---------- tests/pending/run/t4536.check | 8 ---- tests/pending/run/t4536.flags | 1 - tests/pending/run/t4536.scala | 46 -------------------- tests/pending/run/t5733.check | 2 - tests/pending/run/t5733.scala | 53 ----------------------- tests/pending/run/t6355.check | 2 - tests/pending/run/t6355.scala | 17 -------- tests/pending/run/t6663.check | 1 - tests/pending/run/t6663.flags | 1 - tests/pending/run/t6663.scala | 17 -------- tests/run/dynamic-anyval.check | 4 ++ tests/run/dynamic-anyval.scala | 22 ++++++++++ tests/run/t4536.check | 8 ++++ tests/run/t4536.flags | 1 + tests/run/t4536.scala | 42 ++++++++++++++++++ tests/run/t5733.check | 2 + tests/run/t5733.scala | 53 +++++++++++++++++++++++ tests/run/t6355.check | 2 + tests/run/t6355.scala | 17 ++++++++ tests/run/t6663.check | 1 + tests/run/t6663.flags | 1 + tests/run/t6663.scala | 17 ++++++++ tests/untried/neg/applydynamic_sip.check | 73 -------------------------------- tests/untried/neg/applydynamic_sip.flags | 1 - tests/untried/neg/applydynamic_sip.scala | 33 --------------- tests/untried/neg/t6355b.check | 11 ----- tests/untried/neg/t6355b.scala | 17 -------- tests/untried/neg/t6920.check | 6 --- tests/untried/neg/t6920.scala | 10 ----- tests/untried/neg/t8006.check | 6 --- tests/untried/neg/t8006.scala | 8 ---- 42 files changed, 317 insertions(+), 339 deletions(-) create mode 100644 tests/neg/applydynamic_sip.check create mode 100644 tests/neg/applydynamic_sip.flags create mode 100644 tests/neg/applydynamic_sip.scala create mode 100644 tests/neg/t6355b.check create mode 100644 tests/neg/t6355b.scala create mode 100644 tests/neg/t6920.check create mode 100644 tests/neg/t6920.scala create mode 100644 tests/neg/t8006.check create mode 100644 tests/neg/t8006.scala delete mode 100644 tests/pending/run/dynamic-anyval.check delete mode 100644 tests/pending/run/dynamic-anyval.scala delete mode 100644 tests/pending/run/t4536.check delete mode 100644 tests/pending/run/t4536.flags delete mode 100644 tests/pending/run/t4536.scala delete mode 100644 tests/pending/run/t5733.check delete mode 100644 tests/pending/run/t5733.scala delete mode 100644 tests/pending/run/t6355.check delete mode 100644 tests/pending/run/t6355.scala delete mode 100644 tests/pending/run/t6663.check delete mode 100644 tests/pending/run/t6663.flags delete mode 100644 tests/pending/run/t6663.scala create mode 100644 tests/run/dynamic-anyval.check create mode 100644 tests/run/dynamic-anyval.scala create mode 100644 tests/run/t4536.check create mode 100644 tests/run/t4536.flags create mode 100644 tests/run/t4536.scala create mode 100644 tests/run/t5733.check create mode 100644 tests/run/t5733.scala create mode 100644 tests/run/t6355.check create mode 100644 tests/run/t6355.scala create mode 100644 tests/run/t6663.check create mode 100644 tests/run/t6663.flags create mode 100644 tests/run/t6663.scala delete mode 100644 tests/untried/neg/applydynamic_sip.check delete mode 100644 tests/untried/neg/applydynamic_sip.flags delete mode 100644 tests/untried/neg/applydynamic_sip.scala delete mode 100644 tests/untried/neg/t6355b.check delete mode 100644 tests/untried/neg/t6355b.scala delete mode 100644 tests/untried/neg/t6920.check delete mode 100644 tests/untried/neg/t6920.scala delete mode 100644 tests/untried/neg/t8006.check delete mode 100644 tests/untried/neg/t8006.scala (limited to 'tests/run') diff --git a/tests/neg/applydynamic_sip.check b/tests/neg/applydynamic_sip.check new file mode 100644 index 000000000..1bd8304bf --- /dev/null +++ b/tests/neg/applydynamic_sip.check @@ -0,0 +1,52 @@ +tests/neg/applydynamic_sip.scala:8: error: value applyDynamic is not a member of Dynamic(Test.qual) +possible cause: maybe a wrong Dynamic method signature? + qual.sel(a, a2: _*) // error + ^ +tests/neg/applydynamic_sip.scala:9: error: applyDynamicNamed does not support passing a vararg parameter + qual.sel(arg = a, a2: _*) // error + ^ +tests/neg/applydynamic_sip.scala:10: error: applyDynamicNamed does not support passing a vararg parameter + qual.sel(arg, arg2 = "a2", a2: _*) // error + ^ +tests/neg/applydynamic_sip.scala:20: error: type mismatch: + found : String("sel") + required: Int + bad1.sel // error + ^ +tests/neg/applydynamic_sip.scala:21: error: type mismatch: + found : String("sel") + required: Int + bad1.sel(1) // error // error + ^ +tests/neg/applydynamic_sip.scala:21: error: method applyDynamic in class Bad1 does not take more parameters + bad1.sel(1) // error // error + ^ +tests/neg/applydynamic_sip.scala:22: error: type mismatch: + found : String("sel") + required: Int + bad1.sel(a = 1) // error // error + ^ +tests/neg/applydynamic_sip.scala:22: error: method applyDynamicNamed in class Bad1 does not take more parameters + bad1.sel(a = 1) // error // error + ^ +tests/neg/applydynamic_sip.scala:23: error: type mismatch: + found : String("sel") + required: Int + bad1.sel = 1 // error // error + ^ +tests/neg/applydynamic_sip.scala:23: error: method updateDynamic in class Bad1 does not take more parameters + bad1.sel = 1 // error // error + ^ +tests/neg/applydynamic_sip.scala:32: error: method selectDynamic in class Bad2 does not take parameters + bad2.sel // error + ^ +tests/neg/applydynamic_sip.scala:33: error: method applyDynamic in class Bad2 does not take parameters + bad2.sel(1) // error + ^ +tests/neg/applydynamic_sip.scala:34: error: method applyDynamicNamed in class Bad2 does not take parameters + bad2.sel(a = 1) // error + ^ +tests/neg/applydynamic_sip.scala:35: error: method updateDynamic in class Bad2 does not take parameters + bad2.sel = 1 // error + ^ +14 errors found diff --git a/tests/neg/applydynamic_sip.flags b/tests/neg/applydynamic_sip.flags new file mode 100644 index 000000000..1141f9750 --- /dev/null +++ b/tests/neg/applydynamic_sip.flags @@ -0,0 +1 @@ +-language:dynamics diff --git a/tests/neg/applydynamic_sip.scala b/tests/neg/applydynamic_sip.scala new file mode 100644 index 000000000..7b131e7ff --- /dev/null +++ b/tests/neg/applydynamic_sip.scala @@ -0,0 +1,36 @@ +import scala.language.dynamics +object Test extends App { + val qual: Dynamic = ??? + val expr = "expr" + val a = "a" + val a2 = "a2" + + qual.sel(a, a2: _*) // error + qual.sel(arg = a, a2: _*) // error + qual.sel(arg, arg2 = "a2", a2: _*) // error + + class Bad1 extends Dynamic { + def selectDynamic(n: Int) = n + def applyDynamic(n: Int) = n + def applyDynamicNamed(n: Int) = n + def updateDynamic(n: Int) = n + + } + val bad1 = new Bad1 + bad1.sel // error + bad1.sel(1) // error // error + bad1.sel(a = 1) // error // error + bad1.sel = 1 // error // error + + class Bad2 extends Dynamic { + def selectDynamic = 1 + def applyDynamic = 1 + def applyDynamicNamed = 1 + def updateDynamic = 1 + } + val bad2 = new Bad2 + bad2.sel // error + bad2.sel(1) // error + bad2.sel(a = 1) // error + bad2.sel = 1 // error +} diff --git a/tests/neg/t6355b.check b/tests/neg/t6355b.check new file mode 100644 index 000000000..fb73b9c42 --- /dev/null +++ b/tests/neg/t6355b.check @@ -0,0 +1,11 @@ +t6355b.scala:14: error: value applyDynamic is not a member of A +error after rewriting to x.("bippy") +possible cause: maybe a wrong Dynamic method signature? + println(x.bippy(42)) // error + ^ +t6355b.scala:15: error: value applyDynamic is not a member of A +error after rewriting to x.("bippy") +possible cause: maybe a wrong Dynamic method signature? + println(x.bippy("42")) // error + ^ +two errors found diff --git a/tests/neg/t6355b.scala b/tests/neg/t6355b.scala new file mode 100644 index 000000000..bba3c4fdc --- /dev/null +++ b/tests/neg/t6355b.scala @@ -0,0 +1,17 @@ +import scala.language.dynamics + +class A extends Dynamic { + def selectDynamic(method: String): B = new B(method) +} +class B(method: String) { + def apply(x: Int) = s"$method(x: Int) called with x = $x" + def apply(x: String) = s"""$method(x: String) called with x = "$x"""" +} + +object Test { + def main(args: Array[String]): Unit = { + val x = new A + println(x.bippy(42)) // error + println(x.bippy("42")) // error + } +} diff --git a/tests/neg/t6920.check b/tests/neg/t6920.check new file mode 100644 index 000000000..8bfd16a5f --- /dev/null +++ b/tests/neg/t6920.check @@ -0,0 +1,6 @@ +t6920.scala:9: error: too many arguments for method applyDynamicNamed: (values: Seq[(String, Any)])String +error after rewriting to CompilerError.this.test.applyDynamicNamed("crushTheCompiler")(scala.Tuple2("a", 1), scala.Tuple2("b", 2)) +possible cause: maybe a wrong Dynamic method signature? + test.crushTheCompiler(a = 1, b = 2) // error + ^ +one error found diff --git a/tests/neg/t6920.scala b/tests/neg/t6920.scala new file mode 100644 index 000000000..9601ed8d2 --- /dev/null +++ b/tests/neg/t6920.scala @@ -0,0 +1,10 @@ +import scala.language.dynamics + +class DynTest extends Dynamic { + def applyDynamicNamed(name: String)(values: Seq[(String, Any)]) = "test" +} + +class CompilerError { + val test = new DynTest + test.crushTheCompiler(a = 1, b = 2) // error +} diff --git a/tests/neg/t8006.check b/tests/neg/t8006.check new file mode 100644 index 000000000..98207ba30 --- /dev/null +++ b/tests/neg/t8006.check @@ -0,0 +1,6 @@ +t8006.scala:3: error: too many arguments for method applyDynamicNamed: (value: (String, Any))String +error after rewriting to X.this.d.applyDynamicNamed("meth")(scala.Tuple2("value1", 10), scala.Tuple2("value2", 100)) +possible cause: maybe a wrong Dynamic method signature? + d.meth(value1 = 10, value2 = 100) // error: two arguments here, but only one is allowed + ^ +one error found diff --git a/tests/neg/t8006.scala b/tests/neg/t8006.scala new file mode 100644 index 000000000..34946a659 --- /dev/null +++ b/tests/neg/t8006.scala @@ -0,0 +1,8 @@ +object X { + val d = new D + d.meth(value1 = 10, value2 = 100) // error: two arguments here, but only one is allowed +} +import language.dynamics +class D extends Dynamic { + def applyDynamicNamed(name: String)(value: (String, Any)) = name +} diff --git a/tests/pending/run/dynamic-anyval.check b/tests/pending/run/dynamic-anyval.check deleted file mode 100644 index dee7bef8e..000000000 --- a/tests/pending/run/dynamic-anyval.check +++ /dev/null @@ -1,4 +0,0 @@ -().dingo(bippy, 5) -List(1, 2, 3).dingo(bippy, 5) -().dingo(bippy, 5) -List(1, 2, 3).dingo(bippy, 5) diff --git a/tests/pending/run/dynamic-anyval.scala b/tests/pending/run/dynamic-anyval.scala deleted file mode 100644 index 605503d37..000000000 --- a/tests/pending/run/dynamic-anyval.scala +++ /dev/null @@ -1,22 +0,0 @@ -import scala.language.dynamics - -object Test { - implicit class DynamicValue[T](val value: T) extends AnyVal with Dynamic { - def applyDynamic(name: String)(args: Any*) = println(s"""$this.$name(${args mkString ", "})""") - override def toString = "" + value - } - implicit class DynamicValue2[T](val value: T) extends Dynamic { - def applyDynamic(name: String)(args: Any*) = println(s"""$this.$name(${args mkString ", "})""") - override def toString = "" + value - } - - def f[T](x: DynamicValue[T]) = x.dingo("bippy", 5) - def g[T](x: DynamicValue2[T]) = x.dingo("bippy", 5) - - def main(args: Array[String]): Unit = { - f(()) - f(List(1, 2, 3)) - g(()) - g(List(1, 2, 3)) - } -} diff --git a/tests/pending/run/t4536.check b/tests/pending/run/t4536.check deleted file mode 100644 index 0c5a72ada..000000000 --- a/tests/pending/run/t4536.check +++ /dev/null @@ -1,8 +0,0 @@ -cls: bar -obj: foo -obj: bar -cls: bar -obj: bar -trait: pili -trait: mili -trait: foo \ No newline at end of file diff --git a/tests/pending/run/t4536.flags b/tests/pending/run/t4536.flags deleted file mode 100644 index 1141f9750..000000000 --- a/tests/pending/run/t4536.flags +++ /dev/null @@ -1 +0,0 @@ --language:dynamics diff --git a/tests/pending/run/t4536.scala b/tests/pending/run/t4536.scala deleted file mode 100644 index 6661eae6a..000000000 --- a/tests/pending/run/t4536.scala +++ /dev/null @@ -1,46 +0,0 @@ - - - - - - -object dynamicObject extends Dynamic { - def applyDynamic(m: String)() = println("obj: " + m); - this.foo() -} - - -class dynamicClass extends Dynamic { - def applyDynamic(m: String)() = println("cls: " + m); - this.bar() - dynamicObject.bar() -} - - -abstract class dynamicAbstractClass extends Dynamic { - def applyDynamic(m: String)(args: Any*): Unit - this.pili(1, new dynamicClass, "hello"); -} - - -trait dynamicTrait extends Dynamic { - def applyDynamic(m: String)(args: Any*) = println("trait: " + m); - def two = 2 - this.mili(1,2,3) - two -} - - -object dynamicMixin extends dynamicAbstractClass with dynamicTrait { - this.foo(None) -} - - -object Test { - - def main(args: Array[String]) { - val cls = new dynamicClass - dynamicMixin - } - -} diff --git a/tests/pending/run/t5733.check b/tests/pending/run/t5733.check deleted file mode 100644 index e697046a9..000000000 --- a/tests/pending/run/t5733.check +++ /dev/null @@ -1,2 +0,0 @@ -Running ABTest asserts -Done diff --git a/tests/pending/run/t5733.scala b/tests/pending/run/t5733.scala deleted file mode 100644 index a9e58d77e..000000000 --- a/tests/pending/run/t5733.scala +++ /dev/null @@ -1,53 +0,0 @@ -import scala.language.dynamics - -object A extends Dynamic { - var a = "a" - - def selectDynamic(method:String): String = a - - def updateDynamic(method:String)(v:String): Unit = { a = v } -} - -class B extends Dynamic { - var b = "b" - - def selectDynamic(method:String): String = b - - def updateDynamic(method:String)(v:String): Unit = { b = v } -} - -object Test extends dotty.runtime.LegacyApp { - assert( A.foo == "a" ) - assert( A.bar == "a" ) - A.aaa = "aaa" - assert( A.bar == "aaa" ) - - val b = new B - assert( b.foo == "b" ) - assert( b.bar == "b" ) - b.bbb = "bbb" - assert( b.bar == "bbb" ) - - { - println("Running ABTest asserts") - A.a = "a" - (new ABTest).test() - } - - println("Done") -} - -class ABTest { - def test(): Unit = { - assert( A.foo == "a" ) - assert( A.bar == "a" ) - A.aaa = "aaa" - assert( A.bar == "aaa" ) - - val b = new B - assert( b.foo == "b" ) - assert( b.bar == "b" ) - b.bbb = "bbb" - assert( b.bar == "bbb" ) - } -} diff --git a/tests/pending/run/t6355.check b/tests/pending/run/t6355.check deleted file mode 100644 index ce74ab38a..000000000 --- a/tests/pending/run/t6355.check +++ /dev/null @@ -1,2 +0,0 @@ -bippy(x: Int) called with x = 42 -bippy(x: String) called with x = "42" diff --git a/tests/pending/run/t6355.scala b/tests/pending/run/t6355.scala deleted file mode 100644 index f1921391a..000000000 --- a/tests/pending/run/t6355.scala +++ /dev/null @@ -1,17 +0,0 @@ -import scala.language.dynamics - -class A extends Dynamic { - def applyDynamic(method: String): B = new B(method) -} -class B(method: String) { - def apply(x: Int) = s"$method(x: Int) called with x = $x" - def apply(x: String) = s"""$method(x: String) called with x = "$x"""" -} - -object Test { - def main(args: Array[String]): Unit = { - val x = new A - println(x.bippy(42)) - println(x.bippy("42")) - } -} diff --git a/tests/pending/run/t6663.check b/tests/pending/run/t6663.check deleted file mode 100644 index d81cc0710..000000000 --- a/tests/pending/run/t6663.check +++ /dev/null @@ -1 +0,0 @@ -42 diff --git a/tests/pending/run/t6663.flags b/tests/pending/run/t6663.flags deleted file mode 100644 index ea7fc37e1..000000000 --- a/tests/pending/run/t6663.flags +++ /dev/null @@ -1 +0,0 @@ --Yrangepos:false diff --git a/tests/pending/run/t6663.scala b/tests/pending/run/t6663.scala deleted file mode 100644 index bfe464ad6..000000000 --- a/tests/pending/run/t6663.scala +++ /dev/null @@ -1,17 +0,0 @@ -import language.dynamics - -class C(v: Any) extends Dynamic { - def selectDynamic[T](n: String): Option[T] = Option(v.asInstanceOf[T]) - def applyDynamic[T](n: String)(): Option[T] = Option(v.asInstanceOf[T]) -} - -object Test extends dotty.runtime.LegacyApp { - // this should be converted to - // C(42).selectDynamic[Int]("foo").get - // but, before fixing SI-6663, became - // C(42).selectDynamic[Nothing]("foo").get - // leading to a ClassCastException - var v = new C(42).foo[Int].get - println(v) -} - diff --git a/tests/run/dynamic-anyval.check b/tests/run/dynamic-anyval.check new file mode 100644 index 000000000..dee7bef8e --- /dev/null +++ b/tests/run/dynamic-anyval.check @@ -0,0 +1,4 @@ +().dingo(bippy, 5) +List(1, 2, 3).dingo(bippy, 5) +().dingo(bippy, 5) +List(1, 2, 3).dingo(bippy, 5) diff --git a/tests/run/dynamic-anyval.scala b/tests/run/dynamic-anyval.scala new file mode 100644 index 000000000..605503d37 --- /dev/null +++ b/tests/run/dynamic-anyval.scala @@ -0,0 +1,22 @@ +import scala.language.dynamics + +object Test { + implicit class DynamicValue[T](val value: T) extends AnyVal with Dynamic { + def applyDynamic(name: String)(args: Any*) = println(s"""$this.$name(${args mkString ", "})""") + override def toString = "" + value + } + implicit class DynamicValue2[T](val value: T) extends Dynamic { + def applyDynamic(name: String)(args: Any*) = println(s"""$this.$name(${args mkString ", "})""") + override def toString = "" + value + } + + def f[T](x: DynamicValue[T]) = x.dingo("bippy", 5) + def g[T](x: DynamicValue2[T]) = x.dingo("bippy", 5) + + def main(args: Array[String]): Unit = { + f(()) + f(List(1, 2, 3)) + g(()) + g(List(1, 2, 3)) + } +} diff --git a/tests/run/t4536.check b/tests/run/t4536.check new file mode 100644 index 000000000..0c5a72ada --- /dev/null +++ b/tests/run/t4536.check @@ -0,0 +1,8 @@ +cls: bar +obj: foo +obj: bar +cls: bar +obj: bar +trait: pili +trait: mili +trait: foo \ No newline at end of file diff --git a/tests/run/t4536.flags b/tests/run/t4536.flags new file mode 100644 index 000000000..1141f9750 --- /dev/null +++ b/tests/run/t4536.flags @@ -0,0 +1 @@ +-language:dynamics diff --git a/tests/run/t4536.scala b/tests/run/t4536.scala new file mode 100644 index 000000000..89a93a5e0 --- /dev/null +++ b/tests/run/t4536.scala @@ -0,0 +1,42 @@ +import scala.language.dynamics + +object dynamicObject extends Dynamic { + def applyDynamic(m: String)() = println("obj: " + m); + this.foo() +} + + +class dynamicClass extends Dynamic { + def applyDynamic(m: String)() = println("cls: " + m); + this.bar() + dynamicObject.bar() +} + + +abstract class dynamicAbstractClass extends Dynamic { + def applyDynamic(m: String)(args: Any*): Unit + this.pili(1, new dynamicClass, "hello"); +} + + +trait dynamicTrait extends Dynamic { + def applyDynamic(m: String)(args: Any*) = println("trait: " + m); + def two = 2 + this.mili(1,2,3) + two +} + + +object dynamicMixin extends dynamicAbstractClass with dynamicTrait { + this.foo(None) +} + + +object Test { + + def main(args: Array[String]) = { + val cls = new dynamicClass + dynamicMixin + } + +} diff --git a/tests/run/t5733.check b/tests/run/t5733.check new file mode 100644 index 000000000..e697046a9 --- /dev/null +++ b/tests/run/t5733.check @@ -0,0 +1,2 @@ +Running ABTest asserts +Done diff --git a/tests/run/t5733.scala b/tests/run/t5733.scala new file mode 100644 index 000000000..a9e58d77e --- /dev/null +++ b/tests/run/t5733.scala @@ -0,0 +1,53 @@ +import scala.language.dynamics + +object A extends Dynamic { + var a = "a" + + def selectDynamic(method:String): String = a + + def updateDynamic(method:String)(v:String): Unit = { a = v } +} + +class B extends Dynamic { + var b = "b" + + def selectDynamic(method:String): String = b + + def updateDynamic(method:String)(v:String): Unit = { b = v } +} + +object Test extends dotty.runtime.LegacyApp { + assert( A.foo == "a" ) + assert( A.bar == "a" ) + A.aaa = "aaa" + assert( A.bar == "aaa" ) + + val b = new B + assert( b.foo == "b" ) + assert( b.bar == "b" ) + b.bbb = "bbb" + assert( b.bar == "bbb" ) + + { + println("Running ABTest asserts") + A.a = "a" + (new ABTest).test() + } + + println("Done") +} + +class ABTest { + def test(): Unit = { + assert( A.foo == "a" ) + assert( A.bar == "a" ) + A.aaa = "aaa" + assert( A.bar == "aaa" ) + + val b = new B + assert( b.foo == "b" ) + assert( b.bar == "b" ) + b.bbb = "bbb" + assert( b.bar == "bbb" ) + } +} diff --git a/tests/run/t6355.check b/tests/run/t6355.check new file mode 100644 index 000000000..ce74ab38a --- /dev/null +++ b/tests/run/t6355.check @@ -0,0 +1,2 @@ +bippy(x: Int) called with x = 42 +bippy(x: String) called with x = "42" diff --git a/tests/run/t6355.scala b/tests/run/t6355.scala new file mode 100644 index 000000000..f1921391a --- /dev/null +++ b/tests/run/t6355.scala @@ -0,0 +1,17 @@ +import scala.language.dynamics + +class A extends Dynamic { + def applyDynamic(method: String): B = new B(method) +} +class B(method: String) { + def apply(x: Int) = s"$method(x: Int) called with x = $x" + def apply(x: String) = s"""$method(x: String) called with x = "$x"""" +} + +object Test { + def main(args: Array[String]): Unit = { + val x = new A + println(x.bippy(42)) + println(x.bippy("42")) + } +} diff --git a/tests/run/t6663.check b/tests/run/t6663.check new file mode 100644 index 000000000..d81cc0710 --- /dev/null +++ b/tests/run/t6663.check @@ -0,0 +1 @@ +42 diff --git a/tests/run/t6663.flags b/tests/run/t6663.flags new file mode 100644 index 000000000..ea7fc37e1 --- /dev/null +++ b/tests/run/t6663.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/tests/run/t6663.scala b/tests/run/t6663.scala new file mode 100644 index 000000000..bfe464ad6 --- /dev/null +++ b/tests/run/t6663.scala @@ -0,0 +1,17 @@ +import language.dynamics + +class C(v: Any) extends Dynamic { + def selectDynamic[T](n: String): Option[T] = Option(v.asInstanceOf[T]) + def applyDynamic[T](n: String)(): Option[T] = Option(v.asInstanceOf[T]) +} + +object Test extends dotty.runtime.LegacyApp { + // this should be converted to + // C(42).selectDynamic[Int]("foo").get + // but, before fixing SI-6663, became + // C(42).selectDynamic[Nothing]("foo").get + // leading to a ClassCastException + var v = new C(42).foo[Int].get + println(v) +} + diff --git a/tests/untried/neg/applydynamic_sip.check b/tests/untried/neg/applydynamic_sip.check deleted file mode 100644 index 2cb2e7f09..000000000 --- a/tests/untried/neg/applydynamic_sip.check +++ /dev/null @@ -1,73 +0,0 @@ -applydynamic_sip.scala:7: error: applyDynamic does not support passing a vararg parameter - qual.sel(a, a2: _*) - ^ -applydynamic_sip.scala:8: error: applyDynamicNamed does not support passing a vararg parameter - qual.sel(arg = a, a2: _*) - ^ -applydynamic_sip.scala:8: error: not found: value arg - qual.sel(arg = a, a2: _*) - ^ -applydynamic_sip.scala:9: error: applyDynamicNamed does not support passing a vararg parameter - qual.sel(arg, arg2 = "a2", a2: _*) - ^ -applydynamic_sip.scala:9: error: not found: value arg - qual.sel(arg, arg2 = "a2", a2: _*) - ^ -applydynamic_sip.scala:9: error: not found: value arg2 - qual.sel(arg, arg2 = "a2", a2: _*) - ^ -applydynamic_sip.scala:18: error: type mismatch; - found : String("sel") - required: Int -error after rewriting to Test.this.bad1.selectDynamic("sel") -possible cause: maybe a wrong Dynamic method signature? - bad1.sel - ^ -applydynamic_sip.scala:19: error: type mismatch; - found : String("sel") - required: Int -error after rewriting to Test.this.bad1.applyDynamic("sel") -possible cause: maybe a wrong Dynamic method signature? - bad1.sel(1) - ^ -applydynamic_sip.scala:20: error: type mismatch; - found : String("sel") - required: Int -error after rewriting to Test.this.bad1.applyDynamicNamed("sel") -possible cause: maybe a wrong Dynamic method signature? - bad1.sel(a = 1) - ^ -applydynamic_sip.scala:20: error: reassignment to val - bad1.sel(a = 1) - ^ -applydynamic_sip.scala:21: error: type mismatch; - found : String("sel") - required: Int -error after rewriting to Test.this.bad1.updateDynamic("sel") -possible cause: maybe a wrong Dynamic method signature? - bad1.sel = 1 - ^ -applydynamic_sip.scala:29: error: Int does not take parameters -error after rewriting to Test.this.bad2.selectDynamic("sel") -possible cause: maybe a wrong Dynamic method signature? - bad2.sel - ^ -applydynamic_sip.scala:30: error: Int does not take parameters -error after rewriting to Test.this.bad2.applyDynamic("sel") -possible cause: maybe a wrong Dynamic method signature? - bad2.sel(1) - ^ -applydynamic_sip.scala:31: error: Int does not take parameters -error after rewriting to Test.this.bad2.applyDynamicNamed("sel") -possible cause: maybe a wrong Dynamic method signature? - bad2.sel(a = 1) - ^ -applydynamic_sip.scala:31: error: reassignment to val - bad2.sel(a = 1) - ^ -applydynamic_sip.scala:32: error: Int does not take parameters -error after rewriting to Test.this.bad2.updateDynamic("sel") -possible cause: maybe a wrong Dynamic method signature? - bad2.sel = 1 - ^ -16 errors found diff --git a/tests/untried/neg/applydynamic_sip.flags b/tests/untried/neg/applydynamic_sip.flags deleted file mode 100644 index 1141f9750..000000000 --- a/tests/untried/neg/applydynamic_sip.flags +++ /dev/null @@ -1 +0,0 @@ --language:dynamics diff --git a/tests/untried/neg/applydynamic_sip.scala b/tests/untried/neg/applydynamic_sip.scala deleted file mode 100644 index ee4432ebe..000000000 --- a/tests/untried/neg/applydynamic_sip.scala +++ /dev/null @@ -1,33 +0,0 @@ -object Test extends App { - val qual: Dynamic = ??? - val expr = "expr" - val a = "a" - val a2 = "a2" - - qual.sel(a, a2: _*) - qual.sel(arg = a, a2: _*) - qual.sel(arg, arg2 = "a2", a2: _*) - - val bad1 = new Dynamic { - def selectDynamic(n: Int) = n - def applyDynamic(n: Int) = n - def applyDynamicNamed(n: Int) = n - def updateDynamic(n: Int) = n - - } - bad1.sel - bad1.sel(1) - bad1.sel(a = 1) - bad1.sel = 1 - - val bad2 = new Dynamic { - def selectDynamic = 1 - def applyDynamic = 1 - def applyDynamicNamed = 1 - def updateDynamic = 1 - } - bad2.sel - bad2.sel(1) - bad2.sel(a = 1) - bad2.sel = 1 -} diff --git a/tests/untried/neg/t6355b.check b/tests/untried/neg/t6355b.check deleted file mode 100644 index f827f07e5..000000000 --- a/tests/untried/neg/t6355b.check +++ /dev/null @@ -1,11 +0,0 @@ -t6355b.scala:14: error: value applyDynamic is not a member of A -error after rewriting to x.("bippy") -possible cause: maybe a wrong Dynamic method signature? - println(x.bippy(42)) - ^ -t6355b.scala:15: error: value applyDynamic is not a member of A -error after rewriting to x.("bippy") -possible cause: maybe a wrong Dynamic method signature? - println(x.bippy("42")) - ^ -two errors found diff --git a/tests/untried/neg/t6355b.scala b/tests/untried/neg/t6355b.scala deleted file mode 100644 index 5f3c97cb0..000000000 --- a/tests/untried/neg/t6355b.scala +++ /dev/null @@ -1,17 +0,0 @@ -import scala.language.dynamics - -class A extends Dynamic { - def selectDynamic(method: String): B = new B(method) -} -class B(method: String) { - def apply(x: Int) = s"$method(x: Int) called with x = $x" - def apply(x: String) = s"""$method(x: String) called with x = "$x"""" -} - -object Test { - def main(args: Array[String]): Unit = { - val x = new A - println(x.bippy(42)) - println(x.bippy("42")) - } -} diff --git a/tests/untried/neg/t6920.check b/tests/untried/neg/t6920.check deleted file mode 100644 index ee4eafb83..000000000 --- a/tests/untried/neg/t6920.check +++ /dev/null @@ -1,6 +0,0 @@ -t6920.scala:9: error: too many arguments for method applyDynamicNamed: (values: Seq[(String, Any)])String -error after rewriting to CompilerError.this.test.applyDynamicNamed("crushTheCompiler")(scala.Tuple2("a", 1), scala.Tuple2("b", 2)) -possible cause: maybe a wrong Dynamic method signature? - test.crushTheCompiler(a = 1, b = 2) - ^ -one error found diff --git a/tests/untried/neg/t6920.scala b/tests/untried/neg/t6920.scala deleted file mode 100644 index 25dc7b3b6..000000000 --- a/tests/untried/neg/t6920.scala +++ /dev/null @@ -1,10 +0,0 @@ -import scala.language.dynamics - -class DynTest extends Dynamic { - def applyDynamicNamed(name: String)(values: Seq[(String, Any)]) = "test" -} - -class CompilerError { - val test = new DynTest - test.crushTheCompiler(a = 1, b = 2) -} diff --git a/tests/untried/neg/t8006.check b/tests/untried/neg/t8006.check deleted file mode 100644 index fbac26e3a..000000000 --- a/tests/untried/neg/t8006.check +++ /dev/null @@ -1,6 +0,0 @@ -t8006.scala:3: error: too many arguments for method applyDynamicNamed: (value: (String, Any))String -error after rewriting to X.this.d.applyDynamicNamed("meth")(scala.Tuple2("value1", 10), scala.Tuple2("value2", 100)) -possible cause: maybe a wrong Dynamic method signature? - d.meth(value1 = 10, value2 = 100) // two arguments here, but only one is allowed - ^ -one error found diff --git a/tests/untried/neg/t8006.scala b/tests/untried/neg/t8006.scala deleted file mode 100644 index 8dc60697d..000000000 --- a/tests/untried/neg/t8006.scala +++ /dev/null @@ -1,8 +0,0 @@ -object X { - val d = new D - d.meth(value1 = 10, value2 = 100) // two arguments here, but only one is allowed -} -import language.dynamics -class D extends Dynamic { - def applyDynamicNamed(name: String)(value: (String, Any)) = name -} -- cgit v1.2.3