remove / clarify usages of seqToNodeSeq

Author: lrytz

jvm/src/test/scala/scala/xml/SerializationTest.scala

@@ -25,7 +25,7 @@ class SerializationTest {
   def implicitConversion(): Unit = {
     val parent: Elem = <parent><child></child><child/></parent>
     val children: Seq[Node] = parent.child
-    val asNodeSeq: NodeSeq = children
+    val asNodeSeq: NodeSeq = children // implicit seqToNodeSeq
     assertEquals(asNodeSeq, JavaByteSerialization.roundTrip(asNodeSeq))
   }
 }

shared/src/main/scala/scala/xml/Elem.scala

@@ -104,7 +104,7 @@ class Elem(
     scope: NamespaceBinding = this.scope,
     minimizeEmpty: Boolean = this.minimizeEmpty,
     child: Seq[Node] = this.child
-  ): Elem = Elem(prefix, label, attributes, scope, minimizeEmpty, child: _*)
+  ): Elem = Elem(prefix, label, attributes, scope, minimizeEmpty, child.toSeq: _*)
 
   /**
    * Returns concatenation of `text(n)` for each child `n`.

shared/src/main/scala/scala/xml/MetaData.scala

@@ -183,7 +183,7 @@ abstract class MetaData
    * Returns a Map containing the attributes stored as key/value pairs.
    */
   def asAttrMap: Map[String, String] =
-    iterator.map(x => (x.prefixedKey, x.value.text)).toMap
+    iterator.map(x => (x.prefixedKey, NodeSeq.fromSeq(x.value).text)).toMap
 
   /** returns Null or the next MetaData item */
   def next: MetaData

shared/src/main/scala/scala/xml/Utility.scala

@@ -17,6 +17,7 @@ import scala.annotation.tailrec
 import scala.collection.mutable
 import scala.language.implicitConversions
 import scala.collection.Seq
+import scala.collection.immutable.{Seq => ISeq}
 
 /**
  * The `Utility` object provides utility functions for processing instances
@@ -51,12 +52,12 @@ object Utility extends AnyRef with parsing.TokenTests {
    */
   def trim(x: Node): Node = x match {
     case Elem(pre, lab, md, scp, child@_*) =>
-      val children: Seq[Node] = combineAdjacentTextNodes(child).flatMap(trimProper)
+      val children = combineAdjacentTextNodes(child).flatMap(trimProper)
       Elem(pre, lab, md, scp, children.isEmpty, children: _*)
   }
 
-  private def combineAdjacentTextNodes(children: Seq[Node]): Seq[Node] =
-    children.foldRight(Seq.empty[Node]) {
+  private def combineAdjacentTextNodes(children: ScalaVersionSpecific.SeqOfNode): ScalaVersionSpecific.SeqOfNode =
+    children.foldRight(ISeq.empty[Node]) {
       case (Text(left), Text(right) +: nodes) => Text(left + right) +: nodes
       case (n, nodes) => n +: nodes
     }
@@ -67,7 +68,7 @@ object Utility extends AnyRef with parsing.TokenTests {
    */
   def trimProper(x: Node): Seq[Node] = x match {
     case Elem(pre, lab, md, scp, child@_*) =>
-      val children: Seq[Node] = combineAdjacentTextNodes(child).flatMap(trimProper)
+      val children = combineAdjacentTextNodes(child).flatMap(trimProper)
       Elem(pre, lab, md, scp, children.isEmpty, children: _*)
     case Text(s) =>
       new TextBuffer().append(s).toText
@@ -89,7 +90,7 @@ object Utility extends AnyRef with parsing.TokenTests {
    */
   def sort(n: Node): Node = n match {
     case Elem(pre, lab, md, scp, child@_*) =>
-      val children: Seq[Node] = child.map(sort)
+      val children = child.map(sort)
       Elem(pre, lab, sort(md), scp, children.isEmpty, children: _*)
     case _ => n
   }

shared/src/main/scala/scala/xml/factory/XMLLoader.scala

@@ -58,7 +58,7 @@ trait XMLLoader[T <: Node] {
 
   // TODO remove
   def loadXML(inputSource: InputSource, parser: SAXParser): T = getDocElem(adapter.loadDocument(inputSource, parser.getXMLReader))
-  def loadXMLNodes(inputSource: InputSource, parser: SAXParser): Seq[Node] = adapter.loadDocument(inputSource, parser.getXMLReader).children
+  def loadXMLNodes(inputSource: InputSource, parser: SAXParser): Seq[Node] = adapter.loadDocument(inputSource, parser.getXMLReader).children.toSeq
   def adapter: parsing.FactoryAdapter = new parsing.NoBindingFactoryAdapter()
 
   /** Loads XML Document. */
@@ -85,13 +85,13 @@ trait XMLLoader[T <: Node] {
   def loadString(string: String): T = getDocElem(loadStringDocument(string))
 
   /** Load XML nodes, including comments and processing instructions that precede and follow the root element. */
-  def loadNodes(inputSource: InputSource): Seq[Node] = loadDocument(inputSource).children
-  def loadFileNodes(fileName: String): Seq[Node] = loadFileDocument(fileName).children
-  def loadFileNodes(file: File): Seq[Node] = loadFileDocument(file).children
-  def loadNodes(url: URL): Seq[Node] = loadDocument(url).children
-  def loadNodes(sysId: String): Seq[Node] = loadDocument(sysId).children
-  def loadFileNodes(fileDescriptor: FileDescriptor): Seq[Node] = loadFileDocument(fileDescriptor).children
-  def loadNodes(inputStream: InputStream): Seq[Node] = loadDocument(inputStream).children
-  def loadNodes(reader: Reader): Seq[Node] = loadDocument(reader).children
-  def loadStringNodes(string: String): Seq[Node] = loadStringDocument(string).children
+  def loadNodes(inputSource: InputSource): Seq[Node] = loadDocument(inputSource).children.toSeq
+  def loadFileNodes(fileName: String): Seq[Node] = loadFileDocument(fileName).children.toSeq
+  def loadFileNodes(file: File): Seq[Node] = loadFileDocument(file).children.toSeq
+  def loadNodes(url: URL): Seq[Node] = loadDocument(url).children.toSeq
+  def loadNodes(sysId: String): Seq[Node] = loadDocument(sysId).children.toSeq
+  def loadFileNodes(fileDescriptor: FileDescriptor): Seq[Node] = loadFileDocument(fileDescriptor).children.toSeq
+  def loadNodes(inputStream: InputStream): Seq[Node] = loadDocument(inputStream).children.toSeq
+  def loadNodes(reader: Reader): Seq[Node] = loadDocument(reader).children.toSeq
+  def loadStringNodes(string: String): Seq[Node] = loadStringDocument(string).children.toSeq
 }

shared/src/main/scala/scala/xml/parsing/NoBindingFactoryAdapter.scala

@@ -27,7 +27,7 @@ class NoBindingFactoryAdapter extends FactoryAdapter with NodeFactory[Elem] {
 
   /** From NodeFactory.  Constructs an instance of scala.xml.Elem -- TODO: deprecate as in Elem */
   override protected def create(pre: String, label: String, attrs: MetaData, scope: NamespaceBinding, children: Seq[Node]): Elem =
-    Elem(pre, label, attrs, scope, children.isEmpty, children: _*)
+    Elem(pre, label, attrs, scope, children.isEmpty, children.toSeq: _*)
 
   /** From FactoryAdapter.  Creates a node. never creates the same node twice, using hash-consing.
      TODO: deprecate as in Elem, or forward to create?? */

shared/src/main/scala/scala/xml/transform/BasicTransformer.scala

@@ -46,11 +46,11 @@ abstract class BasicTransformer extends (Node => Node) {
     if (n.doTransform) n match {
       case Group(xs) => Group(transform(xs)) // un-group the hack Group tag
       case _ =>
-        val ch: Seq[Node] = n.child
-        val nch: Seq[Node] = transform(ch)
+        val ch = n.child
+        val nch = transform(ch)
 
         if (ch.eq(nch)) n
-        else Elem(n.prefix, n.label, n.attributes, n.scope, nch.isEmpty, nch: _*)
+        else Elem(n.prefix, n.label, n.attributes, n.scope, nch.isEmpty, nch.toSeq: _*)
     }
     else n
 

shared/src/test/scala/scala/xml/AttributeTest.scala

@@ -167,7 +167,7 @@ class AttributeTest {
 
   @Test(expected=classOf[IllegalArgumentException])
   def invalidAttributeFailForMany(): Unit = {
-    <x><y/><z/></x>.child \ "@"
+    <x><y/><z/></x>.child \ "@" // implicit seqToNodeSeq
   }
 
   @Test(expected=classOf[IllegalArgumentException])
@@ -177,6 +177,6 @@ class AttributeTest {
 
   @Test(expected=classOf[IllegalArgumentException])
   def invalidEmptyAttributeFailForMany(): Unit = {
-    <x><y/><z/></x>.child \@ ""
+    <x><y/><z/></x>.child \@ "" // implicit seqToNodeSeq
   }
 }

shared/src/test/scala/scala/xml/NodeSeqTest.scala

@@ -1,6 +1,5 @@
 package scala.xml
 
-import scala.xml.NodeSeq.seqToNodeSeq
 import org.junit.Test
 import org.junit.Assert.assertEquals
 import org.junit.Assert.fail
@@ -30,7 +29,7 @@ class NodeSeqTest {
       case res: Seq[Node] => assertEquals(2, res.size.toLong)
       case _: NodeSeq => fail("Should be Seq[Node] was NodeSeq") // Unreachable code?
     }
-    val res: NodeSeq = a :+ b
+    val res: NodeSeq = a :+ b // implicit seqToNodeSeq
     val exp: NodeSeq = NodeSeq.fromSeq(Seq(<a>Hello</a>, <b>Hi</b>))
     assertEquals(exp, res)
   }
@@ -59,23 +58,23 @@ class NodeSeqTest {
       case res: Seq[Node] => assertEquals(3, res.size.toLong)
       case _: NodeSeq => fail("Should be Seq[Node] was NodeSeq") // Unreachable code?
     }
-    val res: NodeSeq = a ++: b ++: c
+    val res: NodeSeq = a ++: b ++: c // implicit seqToNodeSeq
     val exp: NodeSeq = NodeSeq.fromSeq(Seq(<a>Hello</a>, <b>Hi</b>, <c>Hey</c>))
     assertEquals(exp, res)
   }
 
   @Test
   def testMap(): Unit = {
     val a: NodeSeq = <a>Hello</a>
-    val exp: NodeSeq = Seq(<b>Hi</b>)
+    val exp: NodeSeq = Seq(<b>Hi</b>) // implicit seqToNodeSeq
     assertEquals(exp, a.map(_ => <b>Hi</b>))
     assertEquals(exp, for { _ <- a } yield { <b>Hi</b> })
   }
 
   @Test
   def testFlatMap(): Unit = {
     val a: NodeSeq = <a>Hello</a>
-    val exp: NodeSeq = Seq(<b>Hi</b>)
+    val exp: NodeSeq = Seq(<b>Hi</b>) // implicit seqToNodeSeq
     assertEquals(exp, a.flatMap(_ => Seq(<b>Hi</b>)))
     assertEquals(exp, for { b <- a; _ <- b } yield { <b>Hi</b> })
     assertEquals(exp, for { b <- a; c <- b; _ <- c } yield { <b>Hi</b> })

shared/src/test/scala/scala/xml/ShouldCompile.scala

@@ -70,7 +70,7 @@ class Floozy {
 
 object guardedMatch { // SI-3705
   // guard caused verifyerror in oldpatmat -- TODO: move this to compiler test suite
-  def updateNodes(ns: Seq[Node]): Seq[Node] =
+  def updateNodes(ns: ScalaVersionSpecific.SeqOfNode): ScalaVersionSpecific.SeqOfNode =
     for (subnode <- ns) yield subnode match {
       case <d>{ _ }</d> if true => <d>abc</d>
       case Elem(prefix, label, attribs, scope, children @ _*) =>