Use toVector for XML literal sequences

In `<a><b/><c/><a>`, a `NodeBuffer` (which extends `ArrayBuffer`) is
used to accumulate the children. The buffer is passed to
`new Elem($buf: _*)`, which only works thanks to the implicit
`collection.Seq[Node] => NodeSeq` declared in scala-xml.

With `-Vprint:typer`:

```scala
scala> <a><b/></a>
[[syntax trees at end of                     typer]] // rs$line$1

    val res0: scala.xml.Elem =
      {
        new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null,
          scala.xml.TopScope, false,
          {
            val $buf: scala.xml.NodeBuffer = new _root_.scala.xml.NodeBuffer()
            $buf.&+(
              {
                {
                  new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null,
                    scala.xml.TopScope, true, [ : scala.xml.Node]*)
                }
              }
            )
            scala.xml.NodeSeq.seqToNodeSeq($buf)
          }*
        )
      }
```

The implicit was not inserted in 2.12 because the varargs parameter of
Elem accepted a `collection.Seq`.

Author: lrytz

compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala

@@ -376,7 +376,7 @@ object MarkupParsers {
             content_LT(ts)
             charComingAfter(xSpaceOpt()) == '<'
           } do ()
-          handle.makeXMLseq(Span(start, curOffset, start), ts)
+          handle.makeXMLseq(Span(start, curOffset, start), ts, toVector = false)
         }
         else {
           assert(ts.length == 1, "Require one tree")

compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala

@@ -42,12 +42,14 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
     val _Group: TypeName               = "Group"
     val _MetaData: TypeName            = "MetaData"
     val _NamespaceBinding: TypeName    = "NamespaceBinding"
+    val _Node: TypeName                = "Node"
     val _NodeBuffer: TypeName          = "NodeBuffer"
     val _PrefixedAttribute: TypeName   = "PrefixedAttribute"
     val _ProcInstr: TypeName           = "ProcInstr"
     val _Text: TypeName                = "Text"
     val _Unparsed: TypeName            = "Unparsed"
     val _UnprefixedAttribute: TypeName = "UnprefixedAttribute"
+    val _Seq: TypeName                 = "Seq"
   }
 
   private object xmlterms extends ScalaTermNames {
@@ -59,12 +61,13 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
     val _plus: TermName     = "&+"
     val _tmpscope: TermName = "$tmpscope"
     val _xml: TermName      = "xml"
+    val _toVector: TermName = "toVector"
   }
 
-  import xmltypes.{_Comment, _Elem, _EntityRef, _Group, _MetaData, _NamespaceBinding, _NodeBuffer,
-    _PrefixedAttribute, _ProcInstr, _Text, _Unparsed, _UnprefixedAttribute}
+  import xmltypes.{_Comment, _Elem, _EntityRef, _Group, _MetaData, _NamespaceBinding, _NodeBuffer, _Node,
+    _PrefixedAttribute, _ProcInstr, _Text, _Unparsed, _UnprefixedAttribute, _Seq}
 
-  import xmlterms.{_Null, __Elem, __Text, _buf, _md, _plus, _scope, _tmpscope, _xml}
+  import xmlterms.{_Null, __Elem, __Text, _buf, _md, _plus, _scope, _tmpscope, _xml, _toVector}
 
   // convenience methods
   private def LL[A](x: A*): List[List[A]] = List(x.toList)
@@ -89,6 +92,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
   private def _scala_xml_UnprefixedAttribute= _scala_xml(_UnprefixedAttribute)
   private def _scala_xml__Elem              = _scala_xml(__Elem)
   private def _scala_xml__Text              = _scala_xml(__Text)
+  private def _scala_Seq_Node               = AppliedTypeTree(_scala(_Seq), List(_scala_xml(_Node)))
 
   /** Wildly wrong documentation deleted in favor of "self-documenting code." */
   protected def mkXML(
@@ -103,7 +107,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
   {
     def starArgs =
       if (children.isEmpty) Nil
-      else List(Typed(makeXMLseq(span, children), wildStar))
+      else List(Typed(makeXMLseq(span, children, toVector = true), wildStar))
 
     def pat    = Apply(_scala_xml__Elem, List(pre, label, wild, wild) ::: convertToTextPat(children))
     def nonpat = New(_scala_xml_Elem, List(List(pre, label, attrs, scope, if (empty) Literal(Constant(true)) else Literal(Constant(false))) ::: starArgs))
@@ -152,7 +156,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
     ts match {
       case Nil      => TypedSplice(tpd.ref(defn.NilModule).withSpan(span))
       case t :: Nil => t
-      case _        => makeXMLseq(span, ts)
+      case _        => makeXMLseq(span, ts, toVector = true)
     }
   }
 
@@ -162,11 +166,12 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
   }
 
   /** could optimize if args.length == 0, args.length == 1 AND args(0) is <: Node. */
-  def makeXMLseq(span: Span, args: collection.Seq[Tree]): Block = {
+  def makeXMLseq(span: Span, args: collection.Seq[Tree], toVector: Boolean): Block = {
     val buffer = ValDef(_buf, TypeTree(), New(_scala_xml_NodeBuffer, ListOfNil))
     val applies = args filterNot isEmptyText map (t => Apply(Select(Ident(_buf), _plus), List(t)))
 
-    atSpan(span)(new XMLBlock(buffer :: applies.toList, Ident(_buf)) )
+    val res = if (toVector) Select(Ident(_buf), _toVector) else Ident(_buf)
+    atSpan(span)(new XMLBlock(buffer :: applies.toList, res))
   }
 
   /** Returns (Some(prefix) | None, rest) based on position of ':' */
@@ -177,7 +182,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
 
   /** Various node constructions. */
   def group(span: Span, args: collection.Seq[Tree]): Tree =
-    atSpan(span)( New(_scala_xml_Group, LL(makeXMLseq(span, args))) )
+    atSpan(span)( New(_scala_xml_Group, LL(makeXMLseq(span, args, toVector = true))) )
 
   def unparsed(span: Span, str: String): Tree =
     atSpan(span)( New(_scala_xml_Unparsed, LL(const(str))) )

tests/run/xml.scala

@@ -1,12 +1,21 @@
 
 object Test {
-  import scala.xml.NodeBuffer
+  import scala.xml._
 
   def main(args: Array[String]): Unit = {
     val xml =  <hello>world</hello>
     assert(xml.toString == "helloworld")
-    val nodeBuffer: NodeBuffer = <hello/><world/>
-    assert(nodeBuffer.mkString == "helloworld")
+    val sq: NodeBuffer = <hello/><world/>
+    assert(sq.mkString == "helloworld")
+
+    val subSq: Node = <a><b/><c/></a>
+    assert(subSq.child.toString == "Vector(b, c)") // implementation detail
+
+    val attrSeq: Elem = <a foo="txt&entityref;txt"/>
+    assert(attrSeq.attributes.asInstanceOf[UnprefixedAttribute].value.toString == "Vector(txt, &entityref;, txt)")
+
+    val g: Group = <xml:group><a/><b/><c/></xml:group>
+    assert(g.nodes.toString == "Vector(a, b, c)")
   }
 }
 package scala.xml {
@@ -20,7 +29,7 @@ package scala.xml {
     def child: Seq[Node]
     override def toString = label + child.mkString
   }
-  class Elem(prefix: String, val label: String, attributes1: MetaData, scope: NamespaceBinding, minimizeEmpty: Boolean, val child: Node*) extends Node
+  class Elem(prefix: String, val label: String, val attributes: MetaData, scope: NamespaceBinding, minimizeEmpty: Boolean, val child: Node*) extends Node
   class NodeBuffer extends Seq[Node] {
     val nodes = scala.collection.mutable.ArrayBuffer.empty[Node]
     def &+(o: Any): NodeBuffer =
@@ -39,4 +48,12 @@ package scala.xml {
     def label = t.text
     def child = Nil
   }
+
+  case class UnprefixedAttribute(key: String, value: Seq[Node], next: MetaData)
+  case class EntityRef(entityName: String) extends Node {
+    def label = s"&$entityName;"
+    def child = Nil
+  }
+
+  case class Group(nodes: Seq[Node])
 }