Add underlyingArgument to Tasty reflection.

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -910,6 +910,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def outerSelect(levels: Int, tp: Type)(implicit ctx: Context): Tree =
       untpd.Select(tree, OuterSelectName(EmptyTermName, levels)).withType(SkolemType(tp))
 
+    def underlyingArgument(implicit ctx: Context): Tree = mapToUnderlying.transform(tree)
+
     // --- Higher order traversal methods -------------------------------
 
     /** Apply `f` to each subtree of this tree */
@@ -936,6 +938,18 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
+  /** Map Inlined nodes and InlineProxy references to underlying arguments */
+  object mapToUnderlying extends TreeMap {
+    override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: Ident if tree.symbol.is(InlineProxy) =>
+        tree.symbol.defTree.asInstanceOf[ValOrDefDef].rhs.underlyingArgument
+      case Inlined(_, _, arg) =>
+        arg.underlyingArgument
+      case tree =>
+        super.transform(tree)
+    }
+  }
+
   implicit class ListOfTreeDecorator(val xs: List[tpd.Tree]) extends AnyVal {
     def tpes: List[Type] = xs map (_.tpe)
   }

compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala

@@ -184,6 +184,10 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
   def TermDeco(term: Term): TermAPI = new TermAPI {
     def pos(implicit ctx: Context): Position = term.pos
     def tpe(implicit ctx: Context): Types.Type = term.tpe
+    def underlyingArgument(implicit ctx: Context): Term = {
+      import tpd._
+      term.underlyingArgument
+    }
   }
 
   object IsTerm extends IsTermExtractor {

library/src/scala/tasty/reflect/TreeOps.scala

@@ -147,6 +147,7 @@ trait TreeOps extends TastyCore {
   trait TermAPI {
     def tpe(implicit ctx: Context): Type
     def pos(implicit ctx: Context): Position
+    def underlyingArgument(implicit ctx: Context): Term
   }
   implicit def TermDeco(term: Term): TermAPI
 

tests/disabled/run/xml-interpolation/Test_2.scala renamed to tests/run/xml-interpolation/Test_2.scala

@@ -7,14 +7,14 @@ case class Xml(parts: String, args: List[Any])
 
 // Ideally should be an implicit class but the implicit conversion
 // has to be a inline method
-class XmlQuote(ctx: => StringContext) {
-  inline def xml(args: => Any*): Xml = ~XmlQuote.impl('(ctx), '(args))
+class XmlQuote(val ctx: StringContext) {
+  inline def xml(args: => Any*): Xml = ~XmlQuote.impl('(this), '(args))
 }
 
 object XmlQuote {
-  implicit inline def XmlQuote(ctx: => StringContext): XmlQuote = new XmlQuote(ctx)
+  implicit inline def XmlQuote(ctx: StringContext): XmlQuote = new XmlQuote(ctx)
 
-  def impl(ctx: Expr[StringContext], args: Expr[Seq[Any]])
+  def impl(receiver: Expr[XmlQuote], args: Expr[Seq[Any]])
           (implicit tasty: Tasty): Expr[Xml] = {
     import tasty._
     import Term._
@@ -42,18 +42,20 @@ object XmlQuote {
     }
 
     // _root_.scala.StringContext.apply([p0, ...]: String*)
-    val parts = ctx.toTasty match {
-      case Inlined(_, _,
-        Apply(
-          Select(Select(Select(Ident("_root_"), "scala", _), "StringContext", _), "apply", _),
-          List(Typed(Repeated(values), _)))) if values.forall(isStringConstant) =>
+    val parts = receiver.toTasty.underlyingArgument match {
+      case Apply(
+            Select(New(_), _, _),
+            List(
+              Apply(
+                Select(Select(Select(Ident("_root_"), "scala", _), "StringContext", _), "apply", _),
+                List(Typed(Repeated(values), _))))) if values.forall(isStringConstant) =>
         values.collect { case Literal(Constant.String(value)) => value }
       case tree =>
         abort(s"String literal expected, but $tree found")
     }
 
     // [a0, ...]: Any*
-    val Inlined(_, _, Typed(Repeated(args0), _)) = args.toTasty
+    val Typed(Repeated(args0), _) = args.toTasty.underlyingArgument
 
     val string = parts.mkString("??")
     '(new Xml(~string.toExpr, ~liftListOfAny(args0)))