Initial implementation

Does not work with no splice. See scala/scala3#5119

Author: allanrenucci

src/main/scala/jsx/Jsx.scala

@@ -1,5 +1,25 @@
 package jsx
 
 object Jsx {
-  case class Repr(parts: String, arg: Any)
+  sealed trait Node
+
+  case class Element(
+    name: String,
+    attributes: List[Attribute],
+    children: List[Node]
+  ) extends Node
+
+  object Element {
+    def apply(name: String, attributes: List[Attribute], children: Node*): Element =
+      Element(name, attributes, children.toList)
+  }
+
+  case class Attribute(name: String, value: String)
+
+  case class Text(value: String) extends Node
+
+  // Compile time only.
+  // Ideally, we should have two ASTs. An internal one that
+  // knows about splices and a public one that doesn't.
+  case class Splice(index: Int) extends Node
 }

src/main/scala/jsx/JsxQuote.scala

@@ -1,11 +1,11 @@
 package jsx
 
-import scala.quoted._
+import internal.QuoteImpl
 
 // Ideally should be an implicit class but the implicit conversion
 // has to be a rewrite method
 class JsxQuote(ctx: => StringContext) {
-  rewrite def jsx(args: => Any*): Jsx.Repr = ~Macros.quoteImpl('(ctx), '(args))
+  rewrite def jsx(args: => Any*): Jsx.Element = ~QuoteImpl('(ctx), '(args))
 }
 
 object JsxQuote {

src/main/scala/jsx/Macros.scala

@@ -0,0 +1,13 @@
+package jsx.internal
+
+object Hole {
+  // withing private use area
+  private final val HoleStart = '\uE000'
+  private final val HoleChar  = '\uE001'
+
+  def isHoleStart(ch: Char) = ch == HoleStart
+  def isHoleChar(ch: Char) = isHoleStart(ch) || ch == HoleChar
+
+  def encode(i: Int): String = HoleStart + HoleChar.toString * i
+  def decode(cs: String): Int = cs.takeWhile(isHoleChar).length - 1
+}

src/main/scala/jsx/internal/Hole.scala

@@ -0,0 +1,176 @@
+package jsx.internal
+
+import jsx.Jsx._
+
+final class JsxParser(in: String) {
+  import JsxParser._
+
+  private[this] var offset = 0
+  private def next(): Unit = offset += 1
+  private def isAtEnd = offset >= in.length
+
+  private def error(msg: String, pos: Int = offset): Nothing =
+    throw new ParseError(msg, pos)
+
+  private def ch_unsafe = in.charAt(offset)
+
+  private def ch =
+    if (isAtEnd)
+      error("unexpected end of input")
+    else
+      ch_unsafe
+
+  private def nextChar =
+    if (offset + 1 < in.length) Some(in.charAt(offset + 1))
+    else None
+
+  private def accept(expected: Char): Unit =
+    if (isAtEnd)
+      error(s"expected: '$expected', found end of input")
+    else if (ch_unsafe != expected)
+      error(s"expected: '$expected', found: '$ch_unsafe'")
+    else
+      next()
+
+  private def takeWhile(pred: Char => Boolean): String = {
+    val value = new StringBuilder()
+
+    while (!isAtEnd && pred(ch_unsafe)) {
+      value += ch_unsafe
+      next()
+    }
+
+    value.toString
+  }
+
+  private def spaces(): Unit = takeWhile(_.isWhitespace)
+
+  def parse(): Element = {
+    spaces()
+    val elem = element()
+    spaces()
+
+    if (!isAtEnd)
+      error(s"expected end of input, found $ch")
+
+    elem
+  }
+
+  private def element(): Element = {
+    accept('<')
+    val name = identifier()
+    spaces()
+    val atts = attributes()
+    spaces()
+
+    if (ch == '/') { // closing element (e.g. <div/>)
+      accept('/')
+      accept('>')
+      return Element(name, atts, children = Nil)
+    }
+    accept('>')
+
+    val cs = children()
+
+    accept('<')
+    spaces()
+    accept('/')
+    spaces()
+    val cname = identifier()
+    if (name != cname)
+      error(s"names of opening element and closing element should match: $name != $cname")
+    spaces()
+    accept('>')
+
+    Element(name, atts, cs)
+  }
+
+  private def isNameStart(ch: Char) = ch.isLetter
+
+  private def identifier(): String = {
+    def isNameChar(ch: Char) = isNameStart(ch) || ch == '-'
+
+    val id = takeWhile(isNameChar)
+
+    if (id.isEmpty)
+      error("identifier expected")
+    else if (!isNameStart(id.head))
+      error("unexpected element name start")
+
+    id
+  }
+
+  /** attributes ::= { attribute }
+   */
+  private def attributes(): List[Attribute] = {
+    val atts = List.newBuilder[Attribute]
+
+    def isAttributeStart = !isAtEnd && isNameStart(ch_unsafe)
+
+    while (isAttributeStart) {
+      atts += attribute()
+      spaces()
+    }
+
+    atts.result()
+  }
+
+  /** attribute ::= identifier = attribute_value
+   *
+   *  attribute_value ::= hole
+   *                    | "DoubleStringCharacters"
+   *                    | 'SingleStringCharacters'
+   */
+  private def attribute(): Attribute = {
+    val name = identifier()
+
+    spaces()
+    accept('=')
+    spaces()
+
+    val value = ch match {
+      case '"' =>
+        takeWhile(_ != '"')
+      case '\'' =>
+        takeWhile(_ != '\'')
+      case other =>
+        error(s"""expected: '"' or ''', found: '$other'""")
+    }
+    next()
+
+    Attribute(name, value)
+  }
+
+  private def children(): List[Node] = {
+    val cs = List.newBuilder[Node]
+    var done = false
+
+    while (!done && !isAtEnd) {
+      ch_unsafe match {
+        case '<' =>
+          nextChar match {
+            case None =>
+              error("closing tag or identifier expected", pos = offset + 1)
+            case Some('/') =>
+              done = true
+            case _ =>
+              cs += element()
+          }
+
+        case c if Hole.isHoleStart(c) =>
+          val hole = takeWhile(Hole.isHoleChar)
+          cs += Splice(Hole.decode(hole))
+
+        case _ =>
+          val text = takeWhile(_ != '<')
+          cs += Text(text)
+      }
+    }
+
+    cs.result()
+  }
+}
+
+object JsxParser {
+  final case class ParseError(msg: String, pos: Int) extends Exception(msg)
+}

src/main/scala/jsx/internal/JsxParser.scala

@@ -0,0 +1,36 @@
+package jsx.internal
+
+import scala.quoted._
+
+import jsx.Jsx._
+
+trait Lifter {
+
+  // Only support string splices for now
+  def liftSplice(index: Int): Expr[String]
+
+  def liftElement(elem: Element): Expr[Element] = elem.toExpr
+
+  private implicit val nodeLiftable: Liftable[Node] = {
+    case Splice(index) =>
+      val value = liftSplice(index)
+      '(Text(~value))
+    case Text(value) =>
+      '(Text(~value.toExpr))
+    case elem: Element =>
+      elem.toExpr
+  }
+
+  private implicit val elementLiftable: Liftable[Element] = {
+    case Element(name, attributes, children) =>
+      '(Element(~name.toExpr, ~attributes.toExpr, ~children.toExpr))
+  }
+
+  private implicit val attributeLiftable: Liftable[Attribute] =
+    (att: Attribute) => '(Attribute(~att.name.toExpr, ~att.value.toExpr))
+
+  private implicit def listLiftable[T : Liftable : Type]: Liftable[List[T]] = {
+    case x :: xs  => '{ ~x.toExpr :: ~xs.toExpr }
+    case Nil => '(Nil)
+  }
+}

src/main/scala/jsx/internal/Lifter.scala

@@ -0,0 +1,77 @@
+package jsx.internal
+
+import scala.quoted._
+import scala.tasty.Tasty
+
+import jsx.Jsx.Element
+
+final class QuoteImpl(tasty: Tasty) {
+  import tasty._
+
+  // for debugging purpose
+  private def pp(tree: Tree): Unit = {
+    println(tree.show)
+    println(tasty.showSourceCode.showTree(tree))
+  }
+
+  // TODO: figure out position
+  private def abort(msg: String, pos: Int): Nothing =
+    throw new QuoteError(msg)
+
+  private def mkString(parts: List[String]): String = {
+    val sb = new StringBuilder
+    sb.append(parts.head)
+    for ((part, i) <- parts.tail.zipWithIndex) {
+      sb.append(Hole.encode(i))
+        .append(part)
+    }
+    sb.toString
+  }
+
+  def expr(sc: Expr[StringContext], args: Expr[Seq[Any]]): Expr[Element] = {
+    import Term._
+
+    def isStringConstant(tree: Term) = tree match {
+      case Literal(_) => true // can only be a String, otherwise would not typecheck
+      case _ => false
+    }
+
+    // _root_.scala.StringContext.apply([p0, ...]: String*)
+    val parts = sc.toTasty match {
+      case Inlined(_, _,
+        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 =>
+        // TODO: figure out position
+        pp(tree)
+        abort("String literal expected", 0)
+    }
+
+    val elem =
+      try new JsxParser(mkString(parts)).parse()
+      catch {
+        case JsxParser.ParseError(msg, pos) =>
+          abort(s"Parsing error at pos $pos: $msg", pos)
+      }
+
+    // [a0, ...]: Any*
+    val Inlined(_, _, Typed(Repeated(args0), _)) = args.toTasty
+    val lifter = new Lifter {
+      def liftSplice(index: Int) = {
+        val splice = args0(index)
+        if (splice.tpe <:< definitions.AnyType) // TODO: should be definitions.StringType
+          splice.toExpr[String]
+        else
+         abort(s"Type missmatch: expected String, found ${splice.tpe.show}", 0) // TODO: splice.pos
+      }
+    }
+    lifter.liftElement(elem)
+  }
+}
+
+object QuoteImpl {
+  def apply(sc: Expr[StringContext], args: Expr[Seq[Any]])(implicit tasty: Tasty): Expr[Element] =
+    new QuoteImpl(tasty).expr(sc, args)
+}