scala – String interpolation和macro：如何获取StringContext

object Macros {

  import scala.reflect.macros.Context
  import language.experimental.macros

  sealed trait Piece
  case class Place(str: String) extends Piece
  case class Name(str: String) extends Piece
  case class Pos(column: Int,line: Int)
  case class LocatedPieces(located: List[(String,Pos)])

  implicit class s2pieces(sc: StringContext) {
    def s2(pieces: Piece*) = macro s2impl
  }

  // pieces contain all the Piece instances passed inside of the string interpolation
  def s2impl(c: Context)(pieces: c.Expr[Piece]*): c.Expr[LocatedPieces] = {
    import c.universe.{ Name => _,_ }

    c.prefix.tree match {
      // access data of string interpolation
      case Apply(_,List(Apply(_,rawParts))) =>

        // helper methods
        def typeIdent[A : TypeTag] =
          Ident(typeTag[A].tpe.typeSymbol)

        def companionIdent[A : TypeTag] =
          Ident(typeTag[A].tpe.typeSymbol.companionSymbol)

        def identFromString(tpt: String) =
          Ident(c.mirror.staticModule(tpt))

        // We need to translate the data calculated inside of the macro to an AST
        // in order to write it back to the compiler.
        def toAST(any: Any) =
          Literal(Constant(any))

        def toPosAST(column: Tree,line: Tree) =
          Apply(
            Select(companionIdent[Pos],newTermName("apply")),List(column,line))

        def toTupleAST(t1: Tree,t2: Tree,t3: Tree) =
          Apply(
            TypeApply(
              Select(identFromString("scala.Tuple3"),List(typeIdent[String],typeIdent[Piece],typeIdent[Pos])),List(t1,t2,t3))

        def toLocatedPiecesAST(located: Tree) =
          Apply(
            Select(companionIdent[LocatedPieces],List(located))

        def toListAST(xs: List[Tree]) =
          Apply(
            TypeApply(
              Select(identFromString("scala.collection.immutable.List"),List(AppliedTypeTree(
                typeIdent[Tuple3[String,Pos]],typeIdent[Pos])))),xs)

        // `parts` contain the strings a string interpolation is built of
        val parts = rawParts map { case Literal(Constant(const: String)) => const }
        // translate compiler positions to a data structure that can live outside of the compiler
        val positions = pieces.toList map (_.tree.pos) map (p => Pos(p.column,p.line))
        // discard last element of parts,`transpose` does not work otherwise
        // trim parts to discard unnecessary white space
        val data = List(parts.init map (_.trim),pieces.toList,positions).transpose
        // create an AST containing a List[(String,Pos)]
        val tupleAST = data map { case List(part: String,piece: c.Expr[_],Pos(column,line)) =>
          toTupleAST(toAST(part),piece.tree,toPosAST(toAST(column),toAST(line)))
        }
        // create an AST of `LocatedPieces`
        val locatedPiecesAST = toLocatedPiecesAST(toListAST(tupleAST))
        c.Expr(locatedPiecesAST)

      case _ =>
        c.abort(c.enclosingPosition,"invalid")
    }
  }
}

用法：

object StringContextTest {
  val place: Piece = Place("world")
  val name: Piece = Name("Eric")
  val pieces = s2"""
    Hello $place
    How are you,$name?
  """
  pieces.located foreach println
}

结果：

(Hello,Place(world),Pos(12,9))
(How are you,Name(Eric),Pos(19,10))

我没想到可以花很多时间把所有的东西放在一起,但这是一个愉快的时光.我希望代码符合您的要求.如果您需要更多关于具体情况如何工作的信息,请查看其他问题及其答案：

> Information on how ASTs are constructed
> How to work with TypeTag
> How to use reify in the REPL to get information about the AST

非常感谢Travis Brown(见评论),我得到了一个更短的解决方案来编译：

object Macros {

  import scala.reflect.macros.Context
  import language.experimental.macros

  sealed trait Piece
  case class Place(str: String) extends Piece
  case class Name(str: String) extends Piece
  case class Pos(column: Int,line: Int)
  case class LocatedPieces(located: Seq[(String,Pos)])

  implicit class s2pieces(sc: StringContext) {
    def s2(pieces: Piece*) = macro s2impl
  }

  def s2impl(c: Context)(pieces: c.Expr[Piece]*): c.Expr[LocatedPieces] = {
    import c.universe.{ Name => _,_ }

    def toAST[A : TypeTag](xs: Tree*): Tree =
      Apply(
        Select(Ident(typeOf[A].typeSymbol.companionSymbol),xs.toList)

    val parts = c.prefix.tree match {
      case Apply(_,rawParts))) =>
        rawParts zip (pieces map (_.tree)) map {
          case (Literal(Constant(rawPart: String)),piece) =>
            val line = c.literal(piece.pos.line).tree
            val column = c.literal(piece.pos.column).tree
            val part = c.literal(rawPart.trim).tree
            toAST[(_,_,_)](part,piece,toAST[Pos](line,column))
      }
    }
    c.Expr(toAST[LocatedPieces](toAST[Seq[_]](parts: _*)))
  }
}

它摘录了详细的AST结构,其逻辑略有不同,但几乎相同.如果您在了解代码如何工作方面遇到困难,请首先尝试了解第一个解决方案.它的作用更为明确.