在 CompilerPlugin 中将字符串编译为 AST？

Question

我想创建一个模板插件，并作为第一步将任意字符串转换为其“编译”的 AST 表示形式（我猜，就像 scala 解释器所做的那样）。因此，编译器插件可以将 someString 分配给“HELLO WORLD”：

  @StringAnnotation("""("hello world").toString.toUpperCase""")
  var someString = ""

我当前的第一个镜头插件简而言之：

• runafter 解析器
• 创建一个新的仅表示编译器和一个带有注释内容的 VirtualFile
• 编译和打印 unit.body

请参阅： http://paste.pocoo.org/show/326025/

a) 现在，"object o{val x = 0}" 返回 AST，但例如 "var x = 1+ 2" 不会，因为它不会有效的 .scala 文件。我该如何解决这个问题？

b) onlyPresentation 是一个好的选择吗？我应该用适当的阶段覆盖computeInternalPhases还是使用-Ystop:phase？

c) 是否可以将外部编译器的环境绑定到内部编译器，以便eg

  var x = _
  (...)
  @StringAnnotation("x += 3")

可以工作？

我发现以下代码[1]使用解释器和一个执行类似操作的变量：

  Interpreter interpreter = new Interpreter(settings);
  String[] context = { "FOO" };
  interpreter.bind("context", "Array[String]", context);
  interpreter
    .interpret("de.tutorials.scala2.Test.main(context)");
  context[0] = "BAR";
  interpreter
    .interpret("de.tutorials.scala2.Test.main(context)");

[1] http://www.tutorials.de/java/320639-beispiel-zur-einbindung-des-scala-interpreters-kompilierte-scala-anwendungen。 html#post1653884

感谢

完整代码：

class AnnotationsPI(val global: Global) extends Plugin {
  import global._
  val name = "a_plugins::AnnotationsPI" //a_ to run before namer
  val description = "AST Trans PI"
  val components = List[PluginComponent](Component)

  private object Component extends PluginComponent with Transform with TypingTransformers with TreeDSL {
    val global: AnnotationsPI.this.global.type = AnnotationsPI.this.global
    val runsAfter = List[String]("parser");
    val phaseName = AnnotationsPI.this.name

    def newTransformer(unit: CompilationUnit) = {
      new AnnotationsTransformer(unit)
    }

    val SaTpe = "StringAnnotation".toTypeName

    class AnnotationsTransformer(unit: CompilationUnit) extends TypingTransformer(unit) {

      /** When using <code>preTransform</code>, each node is
       *  visited before its children.
       */
      def preTransform(tree: Tree): Tree = tree match {
        case anno@ValDef(Modifiers(_, _, List(Apply(Select(New(Ident(SaTpe)), _), List(Literal(Constant(a))))), _), b, c, d) => //Apply(Select(New(Ident(SaTpe)), /*nme.CONSTRUCTOR*/_), /*List(x)*/x)
          val str = a.toString
          val strArr = str.getBytes("UTF-8")
          import scala.tools.nsc.{ Global, Settings, SubComponent }
          import scala.tools.nsc.reporters.{ ConsoleReporter, Reporter }

          val settings = new Settings()
          val compiler = new Global(settings, new ConsoleReporter(settings)) {
            override def onlyPresentation = true
          }

          val run = new compiler.Run
          val vfName = "Script.scala"
          var vfile = new scala.tools.nsc.io.VirtualFile(vfName)

          val os = vfile.output
          os.write(strArr, 0, str.size) // void  write(byte[] b, int off, int len) 
          os.close
          new scala.tools.nsc.util.BatchSourceFile(vfName, str)
          run.compileFiles(vfile :: Nil)
          for (unit <- run.units) {
            println("Unit: " + unit)
            println("Body:\n" + unit.body)
          }
          tree

        case _ =>
          tree
      }

      override def transform(tree: Tree): Tree = {
        super.transform(preTransform(tree))
      }
    }
  }

Answer 1

我不知道这是否对您有很大帮助，但是您可以使用 treeFrom( aString )，它是 scala 重构项目的一部分 ( http://scala-refactoring.org/ ）。不过，并没有回答你关于交叉绑定的问题......