From 483bd3cacb34df3b3c2cc205338cb8e12cb89838 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Fri, 31 Jan 2014 15:47:56 +0100 Subject: adds Context.enclosingOwner MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit As per discussion at https://groups.google.com/forum/#!topic/scala-internals/nf_ooEBn6-k, this commit introduces the new c.enclosingOwner API that is going to serve two purposes: 1) provide a better controlled alternative to c.enclosingTree, 2) enable low-level tinkering with owner chains without having to cast to compiler internals. This solution is not ideal, because: 1) symbols are much more than I would like to expose about enclosing lexical contexts (after the aforementioned discussion I’m no longer completely sure whether exposing nothing is the right thing to do, but exposing symbol completers is definitely something that should be avoided), 2) we shouldn’t have to do that low-level stuff in the first place. However, let’s face the facts. This change represents both an improvement over the state of the art wrt #1 and a long-awaited capability wrt #2. I think this pretty much warrants its place in trunk in the spirit of gradual, evolutionary development of reflection API. --- test/files/run/macro-enclosures.check | 2 ++ .../run/macro-enclosures/Impls_Macros_1.scala | 22 ++++++++++++++-------- 2 files changed, 16 insertions(+), 8 deletions(-) (limited to 'test') diff --git a/test/files/run/macro-enclosures.check b/test/files/run/macro-enclosures.check index 36bb67e194..b6fe7a4a91 100644 --- a/test/files/run/macro-enclosures.check +++ b/test/files/run/macro-enclosures.check @@ -30,3 +30,5 @@ enclosingTemplate = scala.AnyRef { } enclosingMethod = def test = Macros.foo enclosingDef = def test = Macros.foo +enclosingOwner = method test +enclosingOwnerChain = List(method test, object Test, package test, package ) diff --git a/test/files/run/macro-enclosures/Impls_Macros_1.scala b/test/files/run/macro-enclosures/Impls_Macros_1.scala index 5b04cf29e9..a0f66a6b98 100644 --- a/test/files/run/macro-enclosures/Impls_Macros_1.scala +++ b/test/files/run/macro-enclosures/Impls_Macros_1.scala @@ -3,15 +3,21 @@ import scala.reflect.macros.blackbox.Context object Macros { def impl(c: Context) = { import c.universe._ - reify { - println("enclosingPackage = " + c.Expr[String](Literal(Constant(c.enclosingPackage.toString))).splice) - println("enclosingClass = " + c.Expr[String](Literal(Constant(c.enclosingClass.toString))).splice) - println("enclosingImpl = " + c.Expr[String](Literal(Constant(c.enclosingImpl.toString))).splice) - println("enclosingTemplate = " + c.Expr[String](Literal(Constant(c.enclosingTemplate.toString))).splice) - println("enclosingMethod = " + c.Expr[String](Literal(Constant(c.enclosingMethod.toString))).splice) - println("enclosingDef = " + c.Expr[String](Literal(Constant(c.enclosingDef.toString))).splice) + def chain(sym: Symbol): List[Symbol] = sym.owner match { + case NoSymbol => sym :: Nil + case owner => sym :: chain(owner) } + q""" + println("enclosingPackage = " + ${c.enclosingPackage.toString}) + println("enclosingClass = " + ${c.enclosingClass.toString}) + println("enclosingImpl = " + ${c.enclosingImpl.toString}) + println("enclosingTemplate = " + ${c.enclosingTemplate.toString}) + println("enclosingMethod = " + ${c.enclosingMethod.toString}) + println("enclosingDef = " + ${c.enclosingDef.toString}) + println("enclosingOwner = " + ${c.enclosingOwner.toString}) + println("enclosingOwnerChain = " + ${chain(c.enclosingOwner).toString}) + """ } - def foo = macro impl + def foo: Any = macro impl } \ No newline at end of file -- cgit v1.2.3