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/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(
@@ -166,7 +170,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
     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)) )
+    atSpan(span)(new XMLBlock(buffer :: applies.toList, Typed(Select(Ident(_buf), _toVector), _scala_Seq_Node)))
   }
 
   /** Returns (Some(prefix) | None, rest) based on position of ':' */

tests/run/xml.scala

@@ -1,12 +1,16 @@
 
 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: Seq[Node] = <hello/><world/>
+    assert(sq.mkString == "helloworld")
+    assert(sq.isInstanceOf[Vector[_]]) // implementation detail
+
+    val subSq: Node = <a><b/><c/></a>
+    assert(subSq.child.toString == "Vector(b, c)") // implementation detail
   }
 }
 package scala.xml {