Fix mima errors

Maybe just whitelist binary incompatabilities instead
with mimaBinaryIssueFilters?

https://github.com/typesafehub/migration-manager/wiki/sbt-plugin

Author: ashawley

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

@@ -37,9 +37,9 @@ trait XMLLoader[T <: Node] {
   def loadXML(source: InputSource, parser: SAXParser): T = {
     val newAdapter = adapter
 
-    newAdapter.scopeStack = TopScope :: newAdapter.scopeStack
+    newAdapter.scopes = TopScope :: newAdapter.scopes
     parser.parse(source, newAdapter)
-    newAdapter.scopeStack = newAdapter.scopeStack.tail
+    newAdapter.scopes = newAdapter.scopes.tail
 
     newAdapter.rootElem.asInstanceOf[T]
   }

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

@@ -38,10 +38,16 @@ abstract class FactoryAdapter extends DefaultHandler with factory.XMLLoader[Node
   var rootElem: Node = null
 
   val buffer = new StringBuilder()
-  var attribStack = List.empty[MetaData]
-  var hStack = List.empty[Node] // [ element ] contains siblings
-  var tagStack = List.empty[String]
-  var scopeStack = List.empty[NamespaceBinding]
+  var attribs = List.empty[MetaData]
+  var nodes = List.empty[Node] // [ element ] contains siblings
+  var tags = List.empty[String]
+  var scopes = List.empty[NamespaceBinding]
+
+  // Fix compatability issues. Add MiMa exclusion rules, instead?
+  var attribStack = collection.mutable.Stack(attribs)
+  var hStack = collection.mutable.Stack(nodes)
+  var tagStack = collection.mutable.Stack(tags)
+  var scopeStack = collection.mutable.Stack(scopes)
 
   var curTag: String = null
   var capture: Boolean = false
@@ -121,17 +127,17 @@ abstract class FactoryAdapter extends DefaultHandler with factory.XMLLoader[Node
     attributes: Attributes): Unit =
     {
       captureText()
-      tagStack = curTag :: tagStack
+      tags = curTag :: tags
       curTag = qname
 
       val localName = splitName(qname)._2
       capture = nodeContainsText(localName)
 
-      hStack =  null :: hStack
+      nodes =  null :: nodes
       var m: MetaData = Null
       var scpe: NamespaceBinding =
-        if (scopeStack.isEmpty) TopScope
-        else scopeStack.head
+        if (scopes.isEmpty) TopScope
+        else scopes.head
 
       for (i <- 0 until attributes.getLength()) {
         val qname = attributes getQName i
@@ -146,16 +152,16 @@ abstract class FactoryAdapter extends DefaultHandler with factory.XMLLoader[Node
           m = Attribute(Option(pre), key, Text(value), m)
       }
 
-      scopeStack = scpe :: scopeStack
-      attribStack =  m :: attribStack
+      scopes = scpe :: scopes
+      attribs =  m :: attribs
     }
 
   /**
    * captures text, possibly normalizing whitespace
    */
   def captureText(): Unit = {
     if (capture && buffer.length > 0)
-      hStack = createText(buffer.toString) :: hStack
+      nodes = createText(buffer.toString) :: nodes
 
     buffer.clear()
   }
@@ -169,24 +175,24 @@ abstract class FactoryAdapter extends DefaultHandler with factory.XMLLoader[Node
    */
   override def endElement(uri: String, _localName: String, qname: String): Unit = {
     captureText()
-    val metaData = attribStack.head
-    attribStack = attribStack.tail
+    val metaData = attribs.head
+    attribs = attribs.tail
 
     // reverse order to get it right
-    val v = hStack.takeWhile(_ != null).reverse
-    hStack = hStack.dropWhile(_ != null) match {
+    val v = nodes.takeWhile(_ != null).reverse
+    nodes = nodes.dropWhile(_ != null) match {
       case null :: hs => hs
       case hs => hs
     }
     val (pre, localName) = splitName(qname)
-    val scp = scopeStack.head
-    scopeStack = scopeStack.tail
+    val scp = scopes.head
+    scopes = scopes.tail
 
     // create element
     rootElem = createNode(pre, localName, metaData, scp, v)
-    hStack = rootElem :: hStack
-    curTag = tagStack.head
-    tagStack = tagStack.tail
+    nodes = rootElem :: nodes
+    curTag = tags.head
+    tags = tags.tail
     capture = curTag != null && nodeContainsText(curTag) // root level
   }
 
@@ -195,6 +201,6 @@ abstract class FactoryAdapter extends DefaultHandler with factory.XMLLoader[Node
    */
   override def processingInstruction(target: String, data: String) {
     captureText()
-    hStack = hStack.reverse_:::(createProcInstr(target, data).toList)
+    nodes = nodes.reverse_:::(createProcInstr(target, data).toList)
   }
 }