From fa8f4022754356859f3af1c4ffbac02ab3dc3e7c Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Sat, 1 Feb 2014 00:46:07 +0100 Subject: some renamings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- test/files/run/reflection-enclosed-inner-basic.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'test/files/run/reflection-enclosed-inner-basic.scala') 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 -- cgit v1.2.3