MethodSymbol.params => MethodSymbol.paramss

This matter was discussed at scala-internals:
http://groups.google.com/group/scala-internals/browse_thread/thread/6414d200cf31c357

And I am convinced with Paul's argument: consistency of the convention
is very important.

3 files changed, 12 insertions, 12 deletions

diff --git a/test/files/run/reflection-implicit.scala b/test/files/run/reflection-implicit.scala
index 637ef24e14..0bcb0bc3a0 100644
--- a/test/files/run/reflection-implicit.scala
+++ b/test/files/run/reflection-implicit.scala
@@ -9,7 +9,7 @@ class C {
 object Test extends App {
   val decls = typeOf[C].typeSymbol.typeSignature.declarations.sorted.toList.filter(sym => !sym.isTerm || (sym.isMethod && !sym.asMethod.isConstructor))
   println(decls map (_.isImplicit))
-  val param = decls.find(_.name.toString == "d").get.asMethod.params.last.head
+  val param = decls.find(_.name.toString == "d").get.asMethod.paramss.last.head
   param.typeSignature
   println(param.isImplicit)
 }
\ No newline at end of file
diff --git a/test/files/run/reflection-methodsymbol-params.scala b/test/files/run/reflection-methodsymbol-params.scala
index 7174c6f49b..45b1f9628f 100644
--- a/test/files/run/reflection-methodsymbol-params.scala
+++ b/test/files/run/reflection-methodsymbol-params.scala
@@ -13,12 +13,12 @@ class C {
 }
 
 object Test extends App {
-  println(typeOf[C].member(newTermName("x1")).asMethod.params)
-  println(typeOf[C].member(newTermName("x2")).asMethod.params)
-  println(typeOf[C].member(newTermName("x3")).asMethod.params)
-  println(typeOf[C].member(newTermName("x4")).asMethod.params)
-  println(typeOf[C].member(newTermName("y1")).asMethod.params)
-  println(typeOf[C].member(newTermName("y2")).asMethod.params)
-  println(typeOf[C].member(newTermName("y3")).asMethod.params)
-  println(typeOf[C].member(newTermName("y4")).asMethod.params)
+  println(typeOf[C].member(newTermName("x1")).asMethod.paramss)
+  println(typeOf[C].member(newTermName("x2")).asMethod.paramss)
+  println(typeOf[C].member(newTermName("x3")).asMethod.paramss)
+  println(typeOf[C].member(newTermName("x4")).asMethod.paramss)
+  println(typeOf[C].member(newTermName("y1")).asMethod.paramss)
+  println(typeOf[C].member(newTermName("y2")).asMethod.paramss)
+  println(typeOf[C].member(newTermName("y3")).asMethod.paramss)
+  println(typeOf[C].member(newTermName("y4")).asMethod.paramss)
 }
\ No newline at end of file
diff --git a/test/files/run/reflection-valueclasses-magic.scala b/test/files/run/reflection-valueclasses-magic.scala
index f9feb2d504..a40b570774 100644
--- a/test/files/run/reflection-valueclasses-magic.scala
+++ b/test/files/run/reflection-valueclasses-magic.scala
@@ -7,7 +7,7 @@ object Test extends App {
   def key(sym: Symbol) = {
     sym match {
       // initialize parameter symbols
-      case meth: MethodSymbol => meth.params.flatten.map(_.typeSignature)
+      case meth: MethodSymbol => meth.paramss.flatten.map(_.typeSignature)
     }
     sym + ": " + sym.typeSignature
   }
@@ -41,8 +41,8 @@ object Test extends App {
     val meth = tpe.declaration(newTermName(method).encodedName.toTermName)
     val testees = if (meth.isMethod) List(meth.asMethod) else meth.asTerm.alternatives.map(_.asMethod)
     testees foreach (testee => {
-      val convertedArgs = args.zipWithIndex.map { case (arg, i) => convert(arg, testee.params.flatten.apply(i).typeSignature) }
-      print(s"testing ${tpe.typeSymbol.name}.$method(${testee.params.flatten.map(_.typeSignature).mkString(','.toString)}) with receiver = $receiver and args = ${convertedArgs.map(arg => arg + ' '.toString + arg.getClass).toList}: ")
+      val convertedArgs = args.zipWithIndex.map { case (arg, i) => convert(arg, testee.paramss.flatten.apply(i).typeSignature) }
+      print(s"testing ${tpe.typeSymbol.name}.$method(${testee.paramss.flatten.map(_.typeSignature).mkString(','.toString)}) with receiver = $receiver and args = ${convertedArgs.map(arg => arg + ' '.toString + arg.getClass).toList}: ")
       wrap(cm.reflect(receiver).reflectMethod(testee)(convertedArgs: _*))
     })
   }