Change Node.child return type to immutable.Seq on 2.13+

Change the type of `Node.child` and `Node.nonEmptyChildren` from
`collection.Seq` to `immutable.Seq` in 2.13+.

A parent is added to `Node` which defines the old signatures for
`child` / `nonEmptyChildren`. This (and the resulting bridge methods)
ensures binary compatbility.

Author: lrytz

build.sbt

@@ -1,4 +1,5 @@
-import sbtcrossproject.CrossPlugin.autoImport.{crossProject, CrossType}
+import com.typesafe.tools.mima.core._
+import sbtcrossproject.CrossPlugin.autoImport.{CrossType, crossProject}
 
 publish / skip := true  // root project
 
@@ -68,6 +69,10 @@ lazy val xml = crossProject(JSPlatform, JVMPlatform, NativePlatform)
       //import com.typesafe.tools.mima.core.{}
       //import com.typesafe.tools.mima.core.ProblemFilters
       Seq( // exclusions for all Scala versions
+        // this used to be a declared method, but is now a bridge without generic signature
+        ProblemFilters.exclude[IncompatibleSignatureProblem]("scala.xml.Node.nonEmptyChildren"),
+        // new method in `Node` with return type `immutable.Seq`
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.xml.Node.child"),
       ) ++ (CrossVersion.partialVersion(scalaVersion.value) match {
         case Some((3, _)) => Seq( // Scala 3-specific exclusions
         )

shared/src/main/scala-2.12/scala/xml/ScalaVersionSpecific.scala

@@ -23,6 +23,8 @@ private[xml] object ScalaVersionSpecific {
     override def apply(): mutable.Builder[Node, NodeSeq] = NodeSeq.newBuilder
   }
   type SeqNodeUnapplySeq = scala.collection.Seq[Node]
+
+  type ChildReturnType = scala.collection.Seq[Node]
 }
 
 private[xml] trait ScalaVersionSpecificNodeSeq extends SeqLike[Node, NodeSeq] { self: NodeSeq =>
@@ -33,3 +35,5 @@ private[xml] trait ScalaVersionSpecificNodeSeq extends SeqLike[Node, NodeSeq] {
 private[xml] trait ScalaVersionSpecificNodeBuffer { self: NodeBuffer =>
   override def stringPrefix: String = "NodeBuffer"
 }
+
+private[xml] trait ScalaVersionSpecificNode {self: Node => }

shared/src/main/scala-2.13+/scala/xml/ScalaVersionSpecific.scala

@@ -25,6 +25,8 @@ private[xml] object ScalaVersionSpecific {
     def fromSpecific(from: Coll)(it: IterableOnce[Node]): NodeSeq = (NodeSeq.newBuilder ++= from).result()
   }
   type SeqNodeUnapplySeq = scala.collection.immutable.Seq[Node]
+
+  type ChildReturnType = scala.collection.immutable.Seq[Node]
 }
 
 private[xml] trait ScalaVersionSpecificNodeSeq
@@ -53,3 +55,10 @@ private[xml] trait ScalaVersionSpecificNodeSeq
 private[xml] trait ScalaVersionSpecificNodeBuffer { self: NodeBuffer =>
   override def className: String = "NodeBuffer"
 }
+
+private[xml] trait ScalaVersionSpecificNode { self: Node =>
+  // These methods are overridden in Node with return type `immutable.Seq`. The declarations here result
+  // in a bridge method in `Node` with result type `collection.Seq` which is needed for binary compatibility.
+  def child: scala.collection.Seq[Node]
+  def nonEmptyChildren: scala.collection.Seq[Node]
+}

shared/src/main/scala-3/scala/xml/ScalaVersionSpecificReturnTypes.scala

@@ -19,18 +19,18 @@ package scala.xml
  What should have been specified explicitly is given in the comments;
  next time we break binary compatibility the types should be changed in the code and this class removed.
  */
-private[xml] object ScalaVersionSpecificReturnTypes { // should be
-  type ExternalIDAttribute = MetaData                 // Null.type
-  type NoExternalIDId = String                        // scala.Null
-  type NodeNoAttributes = MetaData                    // Null.type
-  type NullFilter = MetaData                          // Null.type
-  type NullGetNamespace = String                      // scala.Null
-  type NullNext = MetaData                            // scala.Null
-  type NullKey = String                               // scala.Null
-  type NullValue = scala.collection.Seq[Node]         // scala.Null
-  type NullApply1 = scala.collection.Seq[Node]        // scala.Null
-  type NullApply3 = scala.collection.Seq[Node]        // scala.Null
-  type NullRemove = MetaData                          // Null.type
-  type SpecialNodeChild = scala.collection.Seq[Node]  // Nil.type
-  type GroupChild = scala.collection.Seq[Node]        // Nothing
+private[xml] object ScalaVersionSpecificReturnTypes {          // should be
+  type ExternalIDAttribute = MetaData                          // Null.type
+  type NoExternalIDId = String                                 // scala.Null
+  type NodeNoAttributes = MetaData                             // Null.type
+  type NullFilter = MetaData                                   // Null.type
+  type NullGetNamespace = String                               // scala.Null
+  type NullNext = MetaData                                     // scala.Null
+  type NullKey = String                                        // scala.Null
+  type NullValue = scala.collection.Seq[Node]                  // scala.Null
+  type NullApply1 = scala.collection.Seq[Node]                 // scala.Null
+  type NullApply3 = scala.collection.Seq[Node]                 // scala.Null
+  type NullRemove = MetaData                                   // Null.type
+  type SpecialNodeChild = scala.collection.immutable.Seq[Node] // Nil.type
+  type GroupChild = scala.collection.immutable.Seq[Node]       // Nothing
 }

shared/src/main/scala/scala/xml/Node.scala

@@ -45,7 +45,7 @@ object Node {
  *
  * @author  Burak Emir and others
  */
-abstract class Node extends NodeSeq {
+abstract class Node extends NodeSeq with ScalaVersionSpecificNode {
 
   /** prefix of this node */
   def prefix: String = null
@@ -120,12 +120,12 @@ abstract class Node extends NodeSeq {
    *
    * @return all children of this node
    */
-  def child: Seq[Node]
+  def child: ScalaVersionSpecific.ChildReturnType
 
   /**
    * Children which do not stringify to "" (needed for equality)
    */
-  def nonEmptyChildren: Seq[Node] = child.filterNot(_.toString.isEmpty)
+  def nonEmptyChildren: ScalaVersionSpecific.ChildReturnType = child.filterNot(_.toString.isEmpty)
 
   /**
    * Descendant axis (all descendants of this node, not including node itself)