some renamings

It’s almost 1am, so I’m only scratching the surface, mechanistically
applying the renames that I’ve written down in my notebook:
  * typeSignature => info
  * declarations => decls
  * nme/tpnme => termNames/typeNames
  * paramss => paramLists
  * allOverriddenSymbols => overrides

Some explanation is in order so that I don’t get crucified :)

1) No information loss happens when abbreviating `typeSignature` and `declarations`.
We already have contractions in a number of our public APIs (e.g. `typeParams`),
and I think it’s fine to shorten words as long as people can understand
the shortened versions without a background in scalac.

2) I agree with Simon that `nme` and `tpnme` are cryptic. I think it would
be thoughtful of us to provide newcomers with better names. To offset
the increase in mouthfulness, I’ve moved `MethodSymbol.isConstructor`
to `Symbol.isConstructor`, which covers the most popular use case for nme’s.

3) I also agree that putting `paramss` is a lot to ask of our users.
The double-“s” convention is very neat, but let’s admit that it’s just
weird for the newcomers. I think `paramLists` is a good compromise here.

4) `allOverriddenSymbols` is my personal complaint. I think it’s a mouthful
and a shorter name would be a much better fit for the public API.

1 files changed, 5 insertions, 5 deletions

diff --git a/test/files/run/reflection-enclosed-inner-basic.scala b/test/files/run/reflection-enclosed-inner-basic.scala
index c1cf9bc336..fd81a8d115 100644
--- a/test/files/run/reflection-enclosed-inner-basic.scala
+++ b/test/files/run/reflection-enclosed-inner-basic.scala
@@ -14,19 +14,19 @@ class B {
 object Test extends App {
   val b = cm.classSymbol(classTag[B].runtimeClass)
   println(b)
-  println(b.typeSignature.declarations.toList)
+  println(b.info.decls.toList)
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testInnerClass(name: String) = {
-    val sym = b.typeSignature.declaration(TypeName(name)).asClass
+    val sym = b.info.decl(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod
     val ctorMirror = cm.reflect(new B).reflectClass(sym).reflectConstructor(ctor)
     val instance = ctorMirror()
     println(instance)
@@ -37,7 +37,7 @@ object Test extends App {
   testInnerClass("B2")
 
   def testInnerModule(name: String) = {
-    val sym = b.typeSignature.declaration(TermName(name)).asModule
+    val sym = b.info.decl(TermName(name)).asModule
     println(sym)
     val moduleMirror = cm.reflect(new B).reflectModule(sym)
     val instance = moduleMirror.instance