7 files changed, 193 insertions, 0 deletions
diff --git a/test/files/neg/applydynamic_sip.check b/test/files/neg/applydynamic_sip.check
new file mode 100644
index 0000000000..8845f68a52
--- /dev/null
+++ b/test/files/neg/applydynamic_sip.check
@@ -0,0 +1,10 @@
+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:9: error: applyDynamicNamed does not support passing a vararg parameter
+  qual.sel(arg, arg2 = "a2", a2: _*)
+       ^
+three errors found
diff --git a/test/files/neg/applydynamic_sip.scala b/test/files/neg/applydynamic_sip.scala
new file mode 100644
index 0000000000..362461577b
--- /dev/null
+++ b/test/files/neg/applydynamic_sip.scala
@@ -0,0 +1,10 @@
+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: _*)
+}
+\ No newline at end of file
diff --git a/test/files/run/applydynamic_sip.check b/test/files/run/applydynamic_sip.check
new file mode 100644
index 0000000000..d94db4417e
--- /dev/null
+++ b/test/files/run/applydynamic_sip.check
@@ -0,0 +1,22 @@
+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)
diff --git a/test/files/run/applydynamic_sip.scala b/test/files/run/applydynamic_sip.scala
new file mode 100644
index 0000000000..57cb4349f7
--- /dev/null
+++ b/test/files/run/applydynamic_sip.scala
@@ -0,0 +1,58 @@
+object Test extends App {
+  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
+}
+\ No newline at end of file
diff --git a/test/files/run/dynamic-proxy.check b/test/files/run/dynamic-proxy.check
new file mode 100644
index 0000000000..d1b85daff4
--- /dev/null
+++ b/test/files/run/dynamic-proxy.check
@@ -0,0 +1,20 @@
+noargs
+noargs
+nullary
+value
+symbolic
+symbolic with args
+non-existent method
+before mutation
+mutation 1
+after mutation 1
+mutation 2
+after mutation 2
+overloaded with object
+overloaded with primitive
+overloaded with object in var
+overloaded with object in var 2
+typeArgs: I am a car
+default: 4
+default: 3
+named: 6
diff --git a/test/files/run/dynamic-proxy.flags b/test/files/run/dynamic-proxy.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/run/dynamic-proxy.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/run/dynamic-proxy.scala b/test/files/run/dynamic-proxy.scala
new file mode 100644
index 0000000000..ab5a8b1d66
--- /dev/null
+++ b/test/files/run/dynamic-proxy.scala
@@ -0,0 +1,72 @@
+import scala.reflect._
+
+class Car{ override def toString = "I am a car" }
+object x{
+  def nullary = "nullary"
+  def noargs() = "noargs"
+  def - = "symbolic"
+  def $(s:String) = "symbolic with args"
+  val value = "value"
+  def overloaded(i:Int) = "overloaded with primitive"
+  def overloaded(s:String) = s
+  def default( a:Int, b:Int = 2 ) = "default: "+(a+b)
+  def named( a:Int, b:Int, c:Int ) = "named: "+(a+b+c)
+  def typeArgs[T]( v:T ) = "typeArgs: "+v
+  var mutable = "before mutation"
+  def multiArgLists( a:String )( b:String ) = "multiArgList " + a + b
+  def bar( s:String )(implicit car:Car) = s + car.toString
+}
+
+object Test extends App{
+  val d = new DynamicProxy{ val dynamicProxyTarget = x }
+
+  println( d.noargs )
+  println( d.noargs() )
+  println( d.nullary )
+  println( d.value )
+  println( d.- )
+  println( d.$("x") )
+
+  try{
+    println( d.test )
+  } catch {
+    case _ => println("non-existent method")
+  }
+
+  println( d.mutable )
+  
+  println("mutation 1")
+  d.mutable_=("after mutation 1")
+  println( d.mutable )
+
+  println("mutation 2")
+  d.mutable = "after mutation 2"
+  println( d.mutable )
+
+  println( d.overloaded("overloaded with object") )
+  println( d.overloaded(1) )
+
+  // test some non-constant arguments
+  def s = "overloaded with object in var"
+  println( d.overloaded(s) )
+  println( d.overloaded(s + " 2") )
+  
+  val car = new Car
+  println( d.typeArgs(car) ) // inferred
+  // println( d.typeArgs[Car](car) ) // explicit not working (yet) 
+  
+  println( d.default( 1,3 ) )
+  println( d.default( 1 ) )
+
+  println( d.named(1,c=3,b=2) ) // applyDynamicNamed seems to be broken
+  
+  // println( d.multiArgLists("a")("b") ) // not working yet
+
+  /*
+  // may never work
+  // testing implicit parameters (first test works when moving x into TestDynamicReflect)
+  implicit val car2 = new Car
+  println( d.bar( "Yeah, ") );  // FAILS: could not find implicit value for parameter car
+  {println( d.bar( "Yeah, ") )} // FAILS: could not find implicit value for parameter car
+  */
+}