From 713ce7c5bb01ecf10633193baa66aa7161c68be7 Mon Sep 17 00:00:00 2001
From: clhodapp <clhodapp1@gmail.com>
Date: Fri, 6 Jul 2012 07:04:50 -0500
Subject: New logic for TermSymbol.resolveOverloaded

---
 test/files/run/reflect-overload.scala              | 19 ------
 .../run/reflect-resolveoverload-bynameparam.scala  | 32 +++++++++
 .../run/reflect-resolveoverload-expected.scala     | 43 ++++++++++++
 .../run/reflect-resolveoverload-invalid.scala      | 43 ++++++++++++
 test/files/run/reflect-resolveoverload-named.scala | 26 ++++++++
 test/files/run/reflect-resolveoverload-targs.scala | 29 ++++++++
 .../reflect-resolveoverload-tparm-substitute.scala | 77 ++++++++++++++++++++++
 .../run/reflect-resolveoverload-variadic.scala     | 27 ++++++++
 test/files/run/reflect-resolveoverload1.scala      | 19 ++++++
 test/files/run/reflect-resolveoverload2.scala      | 40 +++++++++++
 10 files changed, 336 insertions(+), 19 deletions(-)
 delete mode 100644 test/files/run/reflect-overload.scala
 create mode 100644 test/files/run/reflect-resolveoverload-bynameparam.scala
 create mode 100644 test/files/run/reflect-resolveoverload-expected.scala
 create mode 100644 test/files/run/reflect-resolveoverload-invalid.scala
 create mode 100644 test/files/run/reflect-resolveoverload-named.scala
 create mode 100644 test/files/run/reflect-resolveoverload-targs.scala
 create mode 100644 test/files/run/reflect-resolveoverload-tparm-substitute.scala
 create mode 100644 test/files/run/reflect-resolveoverload-variadic.scala
 create mode 100644 test/files/run/reflect-resolveoverload1.scala
 create mode 100644 test/files/run/reflect-resolveoverload2.scala

(limited to 'test/files/run')

diff --git a/test/files/run/reflect-overload.scala b/test/files/run/reflect-overload.scala
deleted file mode 100644
index 870a200813..0000000000
--- a/test/files/run/reflect-overload.scala
+++ /dev/null
@@ -1,19 +0,0 @@
-import scala.reflect.runtime.universe._
-import scala.reflect.runtime.{currentMirror => cm}
-
-object Test extends App {
-
-  val s = "hello world"
-  val m = cm.reflect(s)
-  val sc = m.symbol
-  val st = sc.asType
-  val meth = (st member newTermName("indexOf")).asTermSymbol
-  val IntType = definitions.IntClass.asType
-  val indexOf = (meth resolveOverloaded(actuals = List(IntType))).asMethodSymbol
-  assert(m.reflectMethod(indexOf)('w') == 6)
-  assert((m.reflectMethod(indexOf)('w') match { case x: Int => x }) == 6)
-
-  val meth2 = (st member newTermName("substring")).asTermSymbol
-  val substring = (meth2 resolveOverloaded(actuals = List(IntType, IntType))).asMethodSymbol
-  assert(m.reflectMethod(substring)(2, 6) == "llo ")
-}
diff --git a/test/files/run/reflect-resolveoverload-bynameparam.scala b/test/files/run/reflect-resolveoverload-bynameparam.scala
new file mode 100644
index 0000000000..7fb8c82ab8
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload-bynameparam.scala
@@ -0,0 +1,32 @@
+
+class A
+class B extends A
+
+class C {
+  def foo(x: => Int)(y: String) = x
+  def foo(x: String)(y: List[_]) = x
+  def foo(x: => A)(y: Array[_]) = 1
+  def foo(x: A)(y: Seq[_]) = 2
+  def foo(x: B)(y: Map[_, _]) = 4
+}
+
+object Test extends App {
+  val cm = reflect.runtime.currentMirror
+  val u = cm.universe
+  val c = new C
+  val im = cm.reflect(c)
+  val t = u.typeOf[C] member u.newTermName("foo") asTermSymbol
+  val f1 = t.resolveOverloaded(posVargs = List(u.typeOf[Int])) asMethodSymbol
+  val f2 = t.resolveOverloaded(posVargs = List(u.typeOf[String])) asMethodSymbol
+  val f3 = t.resolveOverloaded(posVargs = List(u.typeOf[A])) asMethodSymbol
+  val f4 = t.resolveOverloaded(posVargs = List(u.typeOf[B])) asMethodSymbol
+  val m1 = im.reflectMethod(f1)
+  val m2 = im.reflectMethod(f2)
+  val m3 = im.reflectMethod(f3)
+  val m4 = im.reflectMethod(f4)
+  assert(m1(() => 1, null) == c.foo(1)(null))
+  assert(m2("a", null) == c.foo("a")(null))
+  assert(m3(new A, null) == c.foo(new A)(null))
+  assert(m4(new B, null) == c.foo(new B)(null))
+}
+
diff --git a/test/files/run/reflect-resolveoverload-expected.scala b/test/files/run/reflect-resolveoverload-expected.scala
new file mode 100644
index 0000000000..1378090309
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload-expected.scala
@@ -0,0 +1,43 @@
+
+class A {
+  override def equals(x: Any) = {
+    x.isInstanceOf[A] && !x.isInstanceOf[B]
+  }
+}
+class B extends A {
+  override def equals(x: Any) = {
+    x.isInstanceOf[B]
+  }
+}
+
+class C {
+   def a(x: String) = 1
+   def a(x: Array[_]) = "a"
+   def b(x: String) = new A
+   def b(x: Array[_]) = new B
+   def c(x: String) = new B
+   def c(x: Array[_]) = "a"
+}
+
+object Test extends App {
+  val cm = reflect.runtime.currentMirror
+  val u = cm.universe
+  val c = new C
+  val im = cm.reflect(c)
+  def invoke(s: String, expectedType: u.Type, expectedResult: Any) {
+    val ol = (u.typeOf[C] member u.newTermName(s)).asTermSymbol
+    val methodSym = ol.resolveOverloaded(posVargs = List(u.typeOf[Null]), expected = expectedType).asMethodSymbol
+    val sig = methodSym.typeSignature.asInstanceOf[u.MethodType]
+    val method = im.reflectMethod(methodSym)
+    assert(method(null) == expectedResult)
+  }
+
+  invoke("a", u.typeOf[Int], c.a(null): Int)
+  invoke("a", u.typeOf[String], c.a(null): String)
+  invoke("b", u.typeOf[B], c.b(null): B)
+  invoke("c", u.typeOf[A], c.c(null): A)
+  invoke("c", u.typeOf[A], c.c(null): A)
+  invoke("c", u.typeOf[B], c.c(null): B)
+  invoke("c", u.typeOf[String], c.c(null): String)
+
+}
diff --git a/test/files/run/reflect-resolveoverload-invalid.scala b/test/files/run/reflect-resolveoverload-invalid.scala
new file mode 100644
index 0000000000..def28ccbb4
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload-invalid.scala
@@ -0,0 +1,43 @@
+
+class A
+class B extends A
+
+class C {
+  def a(x: Int) = 1
+  def a(x: String) = 2
+  def b(x: B) = 3
+  def c(x: A, y: B) = 4
+  def c(x: B, y: A) = 5
+  def d[T](x: Int) = 6
+  def d(x: String) = 7
+  def e(x: A) = 8
+  def e(x: =>B) = 9
+}
+
+object Test extends App {
+  val cm = reflect.runtime.currentMirror
+  val u = cm.universe
+
+  val x = new C
+  val t = u.typeOf[C]
+
+  val a = t member u.newTermName("a") asTermSymbol
+  val b = t member u.newTermName("b") asTermSymbol
+  val c = t member u.newTermName("c") asTermSymbol
+  val d = t member u.newTermName("d") asTermSymbol
+  val e = t member u.newTermName("e") asTermSymbol
+
+  val n1 = a.resolveOverloaded(posVargs = List(u.typeOf[Char]))
+  val n2 = b.resolveOverloaded(posVargs = List(u.typeOf[A]))
+  val n3 = c.resolveOverloaded(posVargs = List(u.typeOf[B], u.typeOf[B]))
+  val n4 = d.resolveOverloaded(targs = List(u.typeOf[Int]))
+  val n5 = d.resolveOverloaded()
+  val n6 = e.resolveOverloaded(posVargs = List(u.typeOf[B]))
+  
+  assert(n1 == u.NoSymbol)
+  assert(n2 == u.NoSymbol)
+  assert(n3 == u.NoSymbol)
+  assert(n4 == u.NoSymbol)
+  assert(n5 == u.NoSymbol)
+  assert(n6 == u.NoSymbol)
+}
diff --git a/test/files/run/reflect-resolveoverload-named.scala b/test/files/run/reflect-resolveoverload-named.scala
new file mode 100644
index 0000000000..017ec85c0d
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload-named.scala
@@ -0,0 +1,26 @@
+
+class A {
+  def foo(x: String, y: Int) = 1
+  def foo(x: Int, y: String) = 2
+}
+
+object Test extends App {
+  val cm = reflect.runtime.currentMirror
+  val u = cm.universe
+  val a = new A
+  val im = cm.reflect(a)
+  val tpe = u.typeOf[A]
+  val overloaded = tpe member u.newTermName("foo") asTermSymbol
+  val ms1 =
+    overloaded resolveOverloaded(nameVargs = Seq((u.newTermName("x"), u.typeOf[String]), (u.newTermName("y"), u.typeOf[Int])))
+  val ms2 =
+    overloaded resolveOverloaded(nameVargs = Seq((u.newTermName("y"), u.typeOf[Int]), (u.newTermName("x"), u.typeOf[String])))
+  val ms3 =
+    overloaded resolveOverloaded(nameVargs = Seq((u.newTermName("x"), u.typeOf[Int]), (u.newTermName("y"), u.typeOf[String])))
+  val ms4 =
+    overloaded resolveOverloaded(nameVargs = Seq((u.newTermName("y"), u.typeOf[String]), (u.newTermName("x"), u.typeOf[Int])))
+  assert(im.reflectMethod(ms1 asMethodSymbol)("A", 1) == 1)
+  assert(im.reflectMethod(ms2 asMethodSymbol)("A", 1) == 1)
+  assert(im.reflectMethod(ms3 asMethodSymbol)(1, "A") == 2)
+  assert(im.reflectMethod(ms4 asMethodSymbol)(1, "A") == 2)
+}
diff --git a/test/files/run/reflect-resolveoverload-targs.scala b/test/files/run/reflect-resolveoverload-targs.scala
new file mode 100644
index 0000000000..888b2f0c15
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload-targs.scala
@@ -0,0 +1,29 @@
+
+import reflect.runtime.{universe=>u}
+import scala.reflect.runtime.{currentMirror => cm}
+
+class C {
+   def foo[T: u.TypeTag](x: String) = 1
+   def foo[T: u.TypeTag, S: u.TypeTag](x: String) = 2
+}
+
+object Test extends App {
+  val c = new C
+  val im = cm.reflect(c)
+  val foo = u.typeOf[C] member u.newTermName("foo") asTermSymbol
+  val f1 = foo.resolveOverloaded(
+      targs = Seq(u.typeOf[Int]),
+      posVargs = Seq(u.typeOf[String])
+  )
+
+  val f2 = foo.resolveOverloaded(
+      targs = Seq(u.typeOf[Int],
+        u.typeOf[Int]), posVargs = Seq(u.typeOf[String])
+  )
+
+  val m1 = im.reflectMethod(f1 asMethodSymbol)
+  val m2 = im.reflectMethod(f2 asMethodSymbol)
+
+  assert(m1("a", u.typeTag[Int]) == c.foo[Int]("a"))
+  assert(m2("a", u.typeTag[Int], u.typeTag[Int]) == c.foo[Int, Int]("a"))
+}
diff --git a/test/files/run/reflect-resolveoverload-tparm-substitute.scala b/test/files/run/reflect-resolveoverload-tparm-substitute.scala
new file mode 100644
index 0000000000..22e7bcd40a
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload-tparm-substitute.scala
@@ -0,0 +1,77 @@
+
+class A
+class B extends A
+
+class C {
+  def foo[T](x: T) = x
+  def foo(x: Int) = "a"
+  def foo(x: A) = x
+}
+
+object Test extends App {
+  val cm = reflect.runtime.currentMirror
+  val u = cm.universe
+  val c = new C
+  val im = cm.reflect(c)
+  val term = u.typeOf[C] member u.newTermName("foo") asTermSymbol
+
+  val f1 = term.resolveOverloaded(
+    posVargs = List(u.typeOf[Int]),
+    expected = u.typeOf[String]
+  )
+
+  val f2 = term.resolveOverloaded(
+    targs = List(u.typeOf[String]),
+    posVargs = List(u.typeOf[String]),
+    expected = u.typeOf[String]
+  )
+
+  val f3 = term.resolveOverloaded(
+    posVargs = List(u.typeOf[A]),
+    expected = u.typeOf[A]
+  )
+
+  val f4 = term.resolveOverloaded(
+    targs = List(u.typeOf[A]),
+    posVargs = List(u.typeOf[A]),
+    expected = u.typeOf[A]
+  )
+
+  val f5 = term.resolveOverloaded(
+    targs = List(u.typeOf[B]),
+    posVargs = List(u.typeOf[B]),
+    expected = u.typeOf[B]
+  )
+
+  val f6 = term.resolveOverloaded(
+    targs = List(u.typeOf[B]),
+    posVargs = List(u.typeOf[B]),
+    expected = u.typeOf[A]
+  )
+
+  val f7 = term.resolveOverloaded(
+    targs = List(u.typeOf[A]),
+    posVargs = List(u.typeOf[B]),
+    expected = u.typeOf[A]
+  )
+  
+  val m1 = im.reflectMethod(f1 asMethodSymbol)
+  val m2 = im.reflectMethod(f2 asMethodSymbol)
+  val m3 = im.reflectMethod(f3 asMethodSymbol)
+  val m4 = im.reflectMethod(f4 asMethodSymbol)
+  val m5 = im.reflectMethod(f5 asMethodSymbol)
+  val m6 = im.reflectMethod(f6 asMethodSymbol)
+  val m7 = im.reflectMethod(f7 asMethodSymbol)
+
+  val a = new A
+  val b = new B
+  assert(m1(2) == (c.foo(2): String))
+  assert(m2("xyz") == (c.foo[String]("xyz"): String))
+  assert(m3(a) == (c.foo(a): A))
+  assert(m4(a) == (c.foo[A](a): A))
+  assert(m5(b) == (c.foo[B](b): B))
+  assert(m6(b) == (c.foo[B](b): A))
+  assert(m7(b) == (c.foo[A](b): A))
+
+
+}
diff --git a/test/files/run/reflect-resolveoverload-variadic.scala b/test/files/run/reflect-resolveoverload-variadic.scala
new file mode 100644
index 0000000000..8e2e15600f
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload-variadic.scala
@@ -0,0 +1,27 @@
+
+class C {
+  def foo(x: Int*) = 1 + x.sum
+  def foo(x: String) = 2
+}
+
+object Test extends App {
+  val cm = reflect.runtime.currentMirror
+  val u = cm.universe
+  val c = new C
+  val im = cm.reflect(c)
+  val foo = u.typeOf[C] member u.newTermName("foo") asTermSymbol
+  val f0 = foo.resolveOverloaded()
+  val f1 = foo.resolveOverloaded(posVargs = Seq(u.typeOf[Int]))
+  val f2 = foo.resolveOverloaded(posVargs = Seq(u.typeOf[Int], u.typeOf[Int]))
+  val f3 = foo.resolveOverloaded(posVargs = Seq(u.typeOf[String]))
+
+  val m0 = im.reflectMethod(f0 asMethodSymbol)
+  val m1 = im.reflectMethod(f1 asMethodSymbol)
+  val m2 = im.reflectMethod(f2 asMethodSymbol)
+  val m3 = im.reflectMethod(f3 asMethodSymbol)
+  
+  assert(m0(Seq()) == c.foo())
+  assert(m1(Seq(1)) == c.foo(1))
+  assert(m2(Seq(4, 9)) == c.foo(4, 9))
+  assert(m3("abc") == c.foo("abc"))
+}
diff --git a/test/files/run/reflect-resolveoverload1.scala b/test/files/run/reflect-resolveoverload1.scala
new file mode 100644
index 0000000000..a859a0ec4e
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload1.scala
@@ -0,0 +1,19 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+
+object Test extends App {
+
+  val s = "hello world"
+  val m = cm.reflect(s)
+  val sc = m.symbol
+  val st = sc.asType
+  val meth = (st member newTermName("indexOf")).asTermSymbol
+  val IntType = definitions.IntClass.asType
+  val indexOf = (meth resolveOverloaded(posVargs = List(IntType))).asMethodSymbol
+  assert(m.reflectMethod(indexOf)('w') == 6)
+  assert((m.reflectMethod(indexOf)('w') match { case x: Int => x }) == 6)
+
+  val meth2 = (st member newTermName("substring")).asTermSymbol
+  val substring = (meth2 resolveOverloaded(posVargs = List(IntType, IntType))).asMethodSymbol
+  assert(m.reflectMethod(substring)(2, 6) == "llo ")
+}
diff --git a/test/files/run/reflect-resolveoverload2.scala b/test/files/run/reflect-resolveoverload2.scala
new file mode 100644
index 0000000000..b5f719814b
--- /dev/null
+++ b/test/files/run/reflect-resolveoverload2.scala
@@ -0,0 +1,40 @@
+class A
+class B extends A
+
+class C {
+   def a(x: Int) = 1
+   def a(x: String) = 2
+   //def b(x: => Int)(s: String) = 1
+   //def b(x: => String)(a: Array[_]) = 2
+   def c(x: A) = 1
+   def c(x: B) = 2
+   //def d(x: => A)(s: String) = 1
+   //def d(x: => B)(a: Array[_]) = 2
+   def e(x: A) = 1
+   def e(x: B = new B) = 2
+}
+
+object Test extends App {
+  val cm = reflect.runtime.currentMirror
+  val u = cm.universe
+  val c = new C
+  val im = cm.reflect(c)
+  def invoke(s: String, arg: Any, argType: u.Type): Int = {
+    val ol = u.typeOf[C] member u.newTermName(s) asTermSymbol
+    val methodSym = ol.resolveOverloaded(posVargs = List(argType)) asMethodSymbol
+    val sig = methodSym.typeSignature.asInstanceOf[u.MethodType]
+    val method = im.reflectMethod(methodSym)
+    if (sig.resultType.kind == "MethodType") method(arg, null).asInstanceOf[Int]
+    else method(arg).asInstanceOf[Int]
+  }
+  assert(c.a(1) == invoke("a", 1, u.typeOf[Int]))
+  assert(c.a("a") == invoke("a", "a", u.typeOf[String]))
+  //assert(c.b(1)(null) == invoke("b", 1, u.typeOf[Int]))
+  //assert(c.b("a")(null) == invoke("b", "a", u.typeOf[String]))
+  assert(c.c(new A) == invoke("c", new A, u.typeOf[A]))
+  assert(c.c(new B) == invoke("c", new B, u.typeOf[B]))
+  //assert(c.d(new A)(null) == invoke("d", new A, u.typeOf[A]))
+  //assert(c.d(new B)(null) == invoke("d", new B, u.typeOf[B]))
+  assert(c.e(new A) == invoke("e", new A, u.typeOf[A]))
+  assert(c.e(new B) == invoke("e", new B, u.typeOf[B]))
+}
-- 
cgit v1.2.3