diff --git a/jvm/src/test/scala/scala/xml/XMLTest.scala b/jvm/src/test/scala/scala/xml/XMLTest.scala
index 032b341a..3363a1fb 100644
--- a/jvm/src/test/scala/scala/xml/XMLTest.scala
+++ b/jvm/src/test/scala/scala/xml/XMLTest.scala
@@ -30,10 +30,10 @@ class XMLTestJVM {
   @UnitTest
   def equality = {
     val c = new Node {
-      def label = "hello"
+      override def label = "hello"
       override def hashCode() =
         Utility.hashCode(prefix, label, this.attributes.hashCode(), scope.hashCode(), child)
-      def child = Elem(null, "world", e, sc)
+      override def child = Elem(null, "world", e, sc)
       //def attributes = e
       override def text = ""
     }
@@ -792,7 +792,7 @@ class XMLTestJVM {
   }
 
   def toSource(s: String) = new scala.io.Source {
-    val iter = s.iterator
+    override val iter = s.iterator
     override def reportError(pos: Int, msg: String, out: java.io.PrintStream = Console.err): Unit = {}
   }
 
diff --git a/jvm/src/test/scala/scala/xml/parsing/ConstructingParserTest.scala b/jvm/src/test/scala/scala/xml/parsing/ConstructingParserTest.scala
index fb8590d0..4b8e6037 100644
--- a/jvm/src/test/scala/scala/xml/parsing/ConstructingParserTest.scala
+++ b/jvm/src/test/scala/scala/xml/parsing/ConstructingParserTest.scala
@@ -12,7 +12,7 @@ class ConstructingParserTest {
   def t9060 = {
     val a = """<a xmlns:b·="http://example.com"/>"""
     val source = new Source {
-      val iter = a.iterator
+      override val iter = a.iterator
       override def reportError(pos: Int, msg: String, out: java.io.PrintStream = Console.err) = {}
     }
     val doc = ConstructingParser.fromSource(source, false).content(TopScope)
@@ -42,7 +42,7 @@ class ConstructingParserTest {
 </book>
 
     val source = new Source {
-      val iter = xml.iterator
+      override val iter = xml.iterator
       override def reportError(pos: Int, msg: String, out: java.io.PrintStream = Console.err) = {}
     }
 
@@ -65,7 +65,7 @@ class ConstructingParserTest {
          |</book>""".stripMargin
 
     val source = new Source {
-      val iter = xml.iterator
+      override val iter = xml.iterator
       override def reportError(pos: Int, msg: String, out: java.io.PrintStream = Console.err) = {}
     }
 
diff --git a/shared/src/main/scala-2.13-/scala/xml/ScalaVersionSpecific.scala b/shared/src/main/scala-2.13-/scala/xml/ScalaVersionSpecific.scala
index af7daf76..4a2d66f2 100644
--- a/shared/src/main/scala-2.13-/scala/xml/ScalaVersionSpecific.scala
+++ b/shared/src/main/scala-2.13-/scala/xml/ScalaVersionSpecific.scala
@@ -19,8 +19,8 @@ private[xml] object ScalaVersionSpecific {
   import NodeSeq.Coll
   type CBF[-From, -A, +C] = CanBuildFrom[From, A, C]
   object NodeSeqCBF extends CanBuildFrom[Coll, Node, NodeSeq] {
-    def apply(from: Coll) = NodeSeq.newBuilder
-    def apply() = NodeSeq.newBuilder
+    override def apply(from: Coll) = NodeSeq.newBuilder
+    override def apply() = NodeSeq.newBuilder
   }
 }
 
diff --git a/shared/src/main/scala/scala/xml/Atom.scala b/shared/src/main/scala/scala/xml/Atom.scala
index 89f805c2..98eaeb3d 100644
--- a/shared/src/main/scala/scala/xml/Atom.scala
+++ b/shared/src/main/scala/scala/xml/Atom.scala
@@ -41,13 +41,13 @@ class Atom[+A](val data: A) extends SpecialNode with Serializable {
   final override def doCollectNamespaces = false
   final override def doTransform = false
 
-  def label = "#PCDATA"
+  override def label = "#PCDATA"
 
   /**
    * Returns text, with some characters escaped according to the XML
    *  specification.
    */
-  def buildString(sb: StringBuilder): StringBuilder =
+  override def buildString(sb: StringBuilder): StringBuilder =
     Utility.escape(data.toString, sb)
 
   override def text: String = data.toString
diff --git a/shared/src/main/scala/scala/xml/Attribute.scala b/shared/src/main/scala/scala/xml/Attribute.scala
index f2506d19..62e60ab7 100644
--- a/shared/src/main/scala/scala/xml/Attribute.scala
+++ b/shared/src/main/scala/scala/xml/Attribute.scala
@@ -55,27 +55,27 @@ object Attribute {
  */
 trait Attribute extends MetaData {
   def pre: String // will be null if unprefixed
-  val key: String
-  val value: Seq[Node]
-  val next: MetaData
+  override val key: String
+  override val value: Seq[Node]
+  override val next: MetaData
 
-  def apply(key: String): Seq[Node]
-  def apply(namespace: String, scope: NamespaceBinding, key: String): Seq[Node]
-  def copy(next: MetaData): Attribute
+  override def apply(key: String): Seq[Node]
+  override def apply(namespace: String, scope: NamespaceBinding, key: String): Seq[Node]
+  override def copy(next: MetaData): Attribute
 
-  def remove(key: String) =
+  override def remove(key: String) =
     if (!isPrefixed && this.key == key) next
     else copy(next remove key)
 
-  def remove(namespace: String, scope: NamespaceBinding, key: String) =
+  override def remove(namespace: String, scope: NamespaceBinding, key: String) =
     if (this.key == key && (scope getURI pre) == namespace) next
     else copy(next.remove(namespace, scope, key))
 
-  def isPrefixed: Boolean = pre != null
+  override def isPrefixed: Boolean = pre != null
 
-  def getNamespace(owner: Node): String
+  override def getNamespace(owner: Node): String
 
-  def wellformed(scope: NamespaceBinding): Boolean = {
+  override def wellformed(scope: NamespaceBinding): Boolean = {
     val arg = if (isPrefixed) scope getURI pre else null
     (next(arg, scope, key) == null) && (next wellformed scope)
   }
@@ -94,7 +94,7 @@ trait Attribute extends MetaData {
   /**
    * Appends string representation of only this attribute to stringbuffer.
    */
-  protected def toString1(sb: StringBuilder): Unit = {
+  override protected def toString1(sb: StringBuilder): Unit = {
     if (value == null)
       return
     if (isPrefixed)
diff --git a/shared/src/main/scala/scala/xml/Comment.scala b/shared/src/main/scala/scala/xml/Comment.scala
index 6a80c20c..05a39d21 100644
--- a/shared/src/main/scala/scala/xml/Comment.scala
+++ b/shared/src/main/scala/scala/xml/Comment.scala
@@ -23,7 +23,7 @@ package xml
  */
 case class Comment(commentText: String) extends SpecialNode {
 
-  def label = "#REM"
+  override def label = "#REM"
   override def text = ""
   final override def doCollectNamespaces = false
   final override def doTransform = false
diff --git a/shared/src/main/scala/scala/xml/Document.scala b/shared/src/main/scala/scala/xml/Document.scala
index 5ea235bf..0ff3ad2d 100644
--- a/shared/src/main/scala/scala/xml/Document.scala
+++ b/shared/src/main/scala/scala/xml/Document.scala
@@ -96,7 +96,7 @@ class Document extends NodeSeq with Serializable {
 
   // methods for NodeSeq
 
-  def theSeq: Seq[Node] = this.docElem
+  override def theSeq: Seq[Node] = this.docElem
 
   override def canEqual(other: Any) = other match {
     case _: Document => true
diff --git a/shared/src/main/scala/scala/xml/Elem.scala b/shared/src/main/scala/scala/xml/Elem.scala
index 630aeb16..20feb40a 100755
--- a/shared/src/main/scala/scala/xml/Elem.scala
+++ b/shared/src/main/scala/scala/xml/Elem.scala
@@ -53,11 +53,11 @@ object Elem {
  */
 class Elem(
   override val prefix: String,
-  val label: String,
+  override val label: String,
   attributes1: MetaData,
   override val scope: NamespaceBinding,
   val minimizeEmpty: Boolean,
-  val child: Node*
+  override val child: Node*
 ) extends Node with Serializable {
 
   final override def doCollectNamespaces = true
diff --git a/shared/src/main/scala/scala/xml/EntityRef.scala b/shared/src/main/scala/scala/xml/EntityRef.scala
index 1e94db5f..17eb0543 100644
--- a/shared/src/main/scala/scala/xml/EntityRef.scala
+++ b/shared/src/main/scala/scala/xml/EntityRef.scala
@@ -22,7 +22,7 @@ package xml
 case class EntityRef(entityName: String) extends SpecialNode {
   final override def doCollectNamespaces = false
   final override def doTransform = false
-  def label = "#ENTITY"
+  override def label = "#ENTITY"
 
   override def text = entityName match {
     case "lt"   => "<"
diff --git a/shared/src/main/scala/scala/xml/Group.scala b/shared/src/main/scala/scala/xml/Group.scala
index a53b0f68..9ad9f6ff 100644
--- a/shared/src/main/scala/scala/xml/Group.scala
+++ b/shared/src/main/scala/scala/xml/Group.scala
@@ -41,7 +41,7 @@ final case class Group(nodes: Seq[Node]) extends Node {
    */
   private def fail(msg: String) = throw new UnsupportedOperationException("class Group does not support method '%s'" format msg)
 
-  def label = fail("label")
+  override def label = fail("label")
   override def attributes = fail("attributes")
   override def namespace = fail("namespace")
   override def child = fail("child")
diff --git a/shared/src/main/scala/scala/xml/MetaData.scala b/shared/src/main/scala/scala/xml/MetaData.scala
index 46ef8c62..06470c29 100644
--- a/shared/src/main/scala/scala/xml/MetaData.scala
+++ b/shared/src/main/scala/scala/xml/MetaData.scala
@@ -150,7 +150,7 @@ abstract class MetaData
     case m: MetaData => this.asAttrMap == m.asAttrMap
     case _           => false
   }
-  protected def basisForHashCode: Seq[Any] = List(this.asAttrMap)
+  override protected def basisForHashCode: Seq[Any] = List(this.asAttrMap)
 
   /** filters this sequence of meta data */
   override def filter(f: MetaData => Boolean): MetaData =
diff --git a/shared/src/main/scala/scala/xml/NamespaceBinding.scala b/shared/src/main/scala/scala/xml/NamespaceBinding.scala
index 94caeb23..030358b9 100644
--- a/shared/src/main/scala/scala/xml/NamespaceBinding.scala
+++ b/shared/src/main/scala/scala/xml/NamespaceBinding.scala
@@ -68,7 +68,7 @@ case class NamespaceBinding(prefix: String, uri: String, parent: NamespaceBindin
     case _                   => false
   }
 
-  def basisForHashCode: Seq[Any] = List(prefix, uri, parent)
+  override def basisForHashCode: Seq[Any] = List(prefix, uri, parent)
 
   def buildString(stop: NamespaceBinding): String = sbToString(buildString(_, stop))
 
diff --git a/shared/src/main/scala/scala/xml/Node.scala b/shared/src/main/scala/scala/xml/Node.scala
index d1a34338..6e68a084 100755
--- a/shared/src/main/scala/scala/xml/Node.scala
+++ b/shared/src/main/scala/scala/xml/Node.scala
@@ -165,7 +165,7 @@ abstract class Node extends NodeSeq {
   /**
    *  returns a sequence consisting of only this node
    */
-  def theSeq: Seq[Node] = this :: Nil
+  override def theSeq: Seq[Node] = this :: Nil
 
   /**
    * String representation of this node
diff --git a/shared/src/main/scala/scala/xml/NodeSeq.scala b/shared/src/main/scala/scala/xml/NodeSeq.scala
index 4ccbab39..fe16be05 100644
--- a/shared/src/main/scala/scala/xml/NodeSeq.scala
+++ b/shared/src/main/scala/scala/xml/NodeSeq.scala
@@ -27,7 +27,7 @@ import scala.collection.Seq
 object NodeSeq {
   final val Empty = fromSeq(Nil)
   def fromSeq(s: Seq[Node]): NodeSeq = new NodeSeq {
-    def theSeq = s
+    override def theSeq = s
   }
 
   // ---
@@ -50,10 +50,10 @@ object NodeSeq {
  */
 abstract class NodeSeq extends AbstractSeq[Node] with immutable.Seq[Node] with ScalaVersionSpecificNodeSeq with Equality with Serializable {
   def theSeq: Seq[Node]
-  def length = theSeq.length
+  override def length = theSeq.length
   override def iterator = theSeq.iterator
 
-  def apply(i: Int): Node = theSeq(i)
+  override def apply(i: Int): Node = theSeq(i)
   def apply(f: Node => Boolean): NodeSeq = filter(f)
 
   def xml_sameElements[A](that: Iterable[A]): Boolean = {
@@ -66,7 +66,7 @@ abstract class NodeSeq extends AbstractSeq[Node] with immutable.Seq[Node] with S
     !these.hasNext && !those.hasNext
   }
 
-  protected def basisForHashCode: Seq[Any] = theSeq
+  override protected def basisForHashCode: Seq[Any] = theSeq
 
   override def canEqual(other: Any) = other match {
     case _: NodeSeq => true
diff --git a/shared/src/main/scala/scala/xml/Null.scala b/shared/src/main/scala/scala/xml/Null.scala
index b9896591..3800f185 100644
--- a/shared/src/main/scala/scala/xml/Null.scala
+++ b/shared/src/main/scala/scala/xml/Null.scala
@@ -30,14 +30,14 @@ case object Null extends MetaData {
   override def append(m: MetaData, scope: NamespaceBinding = TopScope): MetaData = m
   override def filter(f: MetaData => Boolean): MetaData = this
 
-  def copy(next: MetaData) = next
-  def getNamespace(owner: Node) = null
+  override def copy(next: MetaData) = next
+  override def getNamespace(owner: Node) = null
 
   override def hasNext = false
-  def next = null
-  def key = null
-  def value = null
-  def isPrefixed = false
+  override def next = null
+  override def key = null
+  override def value = null
+  override def isPrefixed = false
 
   override def length = 0
   override def length(i: Int) = i
@@ -48,12 +48,12 @@ case object Null extends MetaData {
   }
   override protected def basisForHashCode: Seq[Any] = Nil
 
-  def apply(namespace: String, scope: NamespaceBinding, key: String) = null
-  def apply(key: String) =
+  override def apply(namespace: String, scope: NamespaceBinding, key: String) = null
+  override def apply(key: String) =
     if (isNameStart(key.head)) null
     else throw new IllegalArgumentException("not a valid attribute name '" + key + "', so can never match !")
 
-  protected def toString1(sb: StringBuilder) = ()
+  override protected def toString1(sb: StringBuilder) = ()
   override protected def toString1(): String = ""
 
   override def toString(): String = ""
@@ -62,6 +62,6 @@ case object Null extends MetaData {
 
   override def wellformed(scope: NamespaceBinding) = true
 
-  def remove(key: String) = this
-  def remove(namespace: String, scope: NamespaceBinding, key: String) = this
+  override def remove(key: String) = this
+  override def remove(namespace: String, scope: NamespaceBinding, key: String) = this
 }
diff --git a/shared/src/main/scala/scala/xml/PrefixedAttribute.scala b/shared/src/main/scala/scala/xml/PrefixedAttribute.scala
index 56c5a66e..eddea415 100644
--- a/shared/src/main/scala/scala/xml/PrefixedAttribute.scala
+++ b/shared/src/main/scala/scala/xml/PrefixedAttribute.scala
@@ -24,12 +24,12 @@ import scala.collection.Seq
  *  @param next1
  */
 class PrefixedAttribute(
-  val pre: String,
-  val key: String,
-  val value: Seq[Node],
+  override val pre: String,
+  override val key: String,
+  override val value: Seq[Node],
   val next1: MetaData)
   extends Attribute {
-  val next = if (value ne null) next1 else next1.remove(key)
+  override val next = if (value ne null) next1 else next1.remove(key)
 
   /** same as this(pre, key, Text(value), next), or no attribute if value is null */
   def this(pre: String, key: String, value: String, next: MetaData) =
@@ -43,19 +43,19 @@ class PrefixedAttribute(
    * Returns a copy of this unprefixed attribute with the given
    *  next field.
    */
-  def copy(next: MetaData) =
+  override def copy(next: MetaData) =
     new PrefixedAttribute(pre, key, value, next)
 
-  def getNamespace(owner: Node) =
+  override def getNamespace(owner: Node) =
     owner.getNamespace(pre)
 
   /** forwards the call to next (because caller looks for unprefixed attribute */
-  def apply(key: String): Seq[Node] = next(key)
+  override def apply(key: String): Seq[Node] = next(key)
 
   /**
    * gets attribute value of qualified (prefixed) attribute with given key
    */
-  def apply(namespace: String, scope: NamespaceBinding, key: String): Seq[Node] = {
+  override def apply(namespace: String, scope: NamespaceBinding, key: String): Seq[Node] = {
     if (key == this.key && scope.getURI(pre) == namespace)
       value
     else
diff --git a/shared/src/main/scala/scala/xml/ProcInstr.scala b/shared/src/main/scala/scala/xml/ProcInstr.scala
index 04970a22..1d67825d 100644
--- a/shared/src/main/scala/scala/xml/ProcInstr.scala
+++ b/shared/src/main/scala/scala/xml/ProcInstr.scala
@@ -31,7 +31,7 @@ case class ProcInstr(target: String, proctext: String) extends SpecialNode {
   final override def doCollectNamespaces = false
   final override def doTransform = false
 
-  final def label = "#PI"
+  final override def label = "#PI"
   override def text = ""
 
   /**
diff --git a/shared/src/main/scala/scala/xml/SpecialNode.scala b/shared/src/main/scala/scala/xml/SpecialNode.scala
index 775983b1..b10ce16d 100644
--- a/shared/src/main/scala/scala/xml/SpecialNode.scala
+++ b/shared/src/main/scala/scala/xml/SpecialNode.scala
@@ -28,7 +28,7 @@ abstract class SpecialNode extends Node {
   final override def namespace = null
 
   /** always empty */
-  final def child = Nil
+  final override def child = Nil
 
   /** Append string representation to the given string buffer argument. */
   def buildString(sb: StringBuilder): StringBuilder
diff --git a/shared/src/main/scala/scala/xml/UnprefixedAttribute.scala b/shared/src/main/scala/scala/xml/UnprefixedAttribute.scala
index d3b0c679..9a7b71be 100644
--- a/shared/src/main/scala/scala/xml/UnprefixedAttribute.scala
+++ b/shared/src/main/scala/scala/xml/UnprefixedAttribute.scala
@@ -21,12 +21,12 @@ import scala.collection.Seq
  *  @author Burak Emir
  */
 class UnprefixedAttribute(
-  val key: String,
-  val value: Seq[Node],
+  override val key: String,
+  override val value: Seq[Node],
   next1: MetaData)
   extends Attribute {
-  final val pre = null
-  val next = if (value ne null) next1 else next1.remove(key)
+  final override val pre = null
+  override val next = if (value ne null) next1 else next1.remove(key)
 
   /** same as this(key, Text(value), next), or no attribute if value is null */
   def this(key: String, value: String, next: MetaData) =
@@ -37,9 +37,9 @@ class UnprefixedAttribute(
     this(key, value.orNull, next)
 
   /** returns a copy of this unprefixed attribute with the given next field*/
-  def copy(next: MetaData) = new UnprefixedAttribute(key, value, next)
+  override def copy(next: MetaData) = new UnprefixedAttribute(key, value, next)
 
-  final def getNamespace(owner: Node): String = null
+  final override def getNamespace(owner: Node): String = null
 
   /**
    * Gets value of unqualified (unprefixed) attribute with given key, null if not found
@@ -47,7 +47,7 @@ class UnprefixedAttribute(
    * @param  key
    * @return value as Seq[Node] if key is found, null otherwise
    */
-  def apply(key: String): Seq[Node] =
+  override def apply(key: String): Seq[Node] =
     if (key == this.key) value else next(key)
 
   /**
@@ -58,7 +58,7 @@ class UnprefixedAttribute(
    * @param  key
    * @return ..
    */
-  def apply(namespace: String, scope: NamespaceBinding, key: String): Seq[Node] =
+  override def apply(namespace: String, scope: NamespaceBinding, key: String): Seq[Node] =
     next(namespace, scope, key)
 }
 object UnprefixedAttribute {
diff --git a/shared/src/main/scala/scala/xml/dtd/ContentModel.scala b/shared/src/main/scala/scala/xml/dtd/ContentModel.scala
index 6910f13a..2f8506b8 100644
--- a/shared/src/main/scala/scala/xml/dtd/ContentModel.scala
+++ b/shared/src/main/scala/scala/xml/dtd/ContentModel.scala
@@ -28,8 +28,8 @@ object ContentModelLaundry extends ContentModelLaundry {
 
 object ContentModel extends WordExp {
 
-  type _labelT = ElemName
-  type _regexpT = RegExp
+  override type _labelT = ElemName
+  override type _regexpT = RegExp
 
   @deprecated("Avoidance", since="2.10")
   trait Translator extends WordBerrySethi
@@ -114,7 +114,7 @@ sealed abstract class DFAContentModel extends ContentModel {
   }
 }
 
-case class MIXED(r: RegExp) extends DFAContentModel {
+case class MIXED(override val r: RegExp) extends DFAContentModel {
   import ContentModel.Alt
 
   override def buildString(sb: StringBuilder): StringBuilder = {
@@ -126,7 +126,7 @@ case class MIXED(r: RegExp) extends DFAContentModel {
   }
 }
 
-case class ELEMENTS(r: RegExp) extends DFAContentModel {
+case class ELEMENTS(override val r: RegExp) extends DFAContentModel {
   override def buildString(sb: StringBuilder): StringBuilder =
     ContentModel.buildString(r, sb)
 }
diff --git a/shared/src/main/scala/scala/xml/dtd/ExternalID.scala b/shared/src/main/scala/scala/xml/dtd/ExternalID.scala
index 46743025..7344e403 100644
--- a/shared/src/main/scala/scala/xml/dtd/ExternalID.scala
+++ b/shared/src/main/scala/scala/xml/dtd/ExternalID.scala
@@ -48,8 +48,8 @@ sealed abstract class ExternalID extends parsing.TokenTests {
  *  @author Burak Emir
  *  @param  systemId the system identifier literal
  */
-case class SystemID(systemId: String) extends ExternalID {
-  val publicId = null
+case class SystemID(override val systemId: String) extends ExternalID {
+  override val publicId = null
 
   if (!checkSysID(systemId))
     throw new IllegalArgumentException("can't use both \" and ' in systemId")
@@ -62,7 +62,7 @@ case class SystemID(systemId: String) extends ExternalID {
  *  @param  publicId the public identifier literal
  *  @param  systemId (can be null for notation pubIDs) the system identifier literal
  */
-case class PublicID(publicId: String, systemId: String) extends ExternalID {
+case class PublicID(override val publicId: String, override val systemId: String) extends ExternalID {
   if (!checkPubID(publicId))
     throw new IllegalArgumentException("publicId must consist of PubidChars")
 
@@ -85,8 +85,8 @@ case class PublicID(publicId: String, systemId: String) extends ExternalID {
  *  @author Michael Bayne
  */
 object NoExternalID extends ExternalID {
-  val publicId = null
-  val systemId = null
+  override val publicId = null
+  override val systemId = null
 
   override def toString = ""
 }
diff --git a/shared/src/main/scala/scala/xml/dtd/impl/Base.scala b/shared/src/main/scala/scala/xml/dtd/impl/Base.scala
index bb5f1832..4dffb783 100644
--- a/shared/src/main/scala/scala/xml/dtd/impl/Base.scala
+++ b/shared/src/main/scala/scala/xml/dtd/impl/Base.scala
@@ -38,7 +38,7 @@ private[dtd] abstract class Base {
   }
 
   class Alt private (val rs: _regexpT*) extends RegExp {
-    final val isNullable = rs exists (_.isNullable)
+    final override val isNullable = rs exists (_.isNullable)
   }
 
   object Sequ {
@@ -48,22 +48,22 @@ private[dtd] abstract class Base {
   }
 
   class Sequ private (val rs: _regexpT*) extends RegExp {
-    final val isNullable = rs forall (_.isNullable)
+    final override val isNullable = rs forall (_.isNullable)
   }
 
   case class Star(r: _regexpT) extends RegExp {
-    final lazy val isNullable = true
+    final override lazy val isNullable = true
   }
 
   // The empty Sequ.
   case object Eps extends RegExp {
-    final lazy val isNullable = true
+    final override lazy val isNullable = true
     override def toString = "Eps"
   }
 
   /** this class can be used to add meta information to regexps. */
   class Meta(r1: _regexpT) extends RegExp {
-    final val isNullable = r1.isNullable
+    final override val isNullable = r1.isNullable
     def r = r1
   }
 }
diff --git a/shared/src/main/scala/scala/xml/dtd/impl/SubsetConstruction.scala b/shared/src/main/scala/scala/xml/dtd/impl/SubsetConstruction.scala
index e413101f..38c57022 100644
--- a/shared/src/main/scala/scala/xml/dtd/impl/SubsetConstruction.scala
+++ b/shared/src/main/scala/scala/xml/dtd/impl/SubsetConstruction.scala
@@ -104,10 +104,10 @@ private[dtd] class SubsetConstruction[T <: AnyRef](val nfa: NondetWordAutom[T])
     finals foreach { case (k, v) => finalsR(indexMap(k)) = v }
 
     new DetWordAutom[T] {
-      val nstates = nstatesR
-      val delta = deltaR
-      val default = defaultR
-      val finals = finalsR
+      override val nstates = nstatesR
+      override val delta = deltaR
+      override val default = defaultR
+      override val finals = finalsR
     }
   }
 }
diff --git a/shared/src/main/scala/scala/xml/dtd/impl/WordBerrySethi.scala b/shared/src/main/scala/scala/xml/dtd/impl/WordBerrySethi.scala
index 58c3a778..19a5880d 100644
--- a/shared/src/main/scala/scala/xml/dtd/impl/WordBerrySethi.scala
+++ b/shared/src/main/scala/scala/xml/dtd/impl/WordBerrySethi.scala
@@ -159,11 +159,11 @@ private[dtd] abstract class WordBerrySethi extends BaseBerrySethi {
         val defaultArr = (0 until pos map (k => immutable.BitSet(defaultq(k): _*))).toArray
 
         new NondetWordAutom[_labelT] {
-          val nstates = pos
-          val labels = WordBerrySethi.this.labels.toList
-          val finals = finalsArr
-          val delta = deltaArr
-          val default = defaultArr
+          override val nstates = pos
+          override val labels = WordBerrySethi.this.labels.toList
+          override val finals = finalsArr
+          override val delta = deltaArr
+          override val default = defaultArr
         }
       case z =>
         automatonFrom(Sequ(z.asInstanceOf[this.lang._regexpT]), finalTag)
diff --git a/shared/src/main/scala/scala/xml/dtd/impl/WordExp.scala b/shared/src/main/scala/scala/xml/dtd/impl/WordExp.scala
index a34eda9c..a3974ced 100644
--- a/shared/src/main/scala/scala/xml/dtd/impl/WordExp.scala
+++ b/shared/src/main/scala/scala/xml/dtd/impl/WordExp.scala
@@ -45,16 +45,16 @@ private[dtd] abstract class WordExp extends Base {
 
   abstract class Label
 
-  type _regexpT <: RegExp
+  override type _regexpT <: RegExp
   type _labelT <: Label
 
   case class Letter(a: _labelT) extends RegExp {
-    final lazy val isNullable = false
+    final override lazy val isNullable = false
     var pos = -1
   }
 
   case class Wildcard() extends RegExp {
-    final lazy val isNullable = false
+    final override lazy val isNullable = false
     var pos = -1
   }
 }
diff --git a/shared/src/main/scala/scala/xml/include/sax/XIncluder.scala b/shared/src/main/scala/scala/xml/include/sax/XIncluder.scala
index 2dcc69b8..986b1436 100644
--- a/shared/src/main/scala/scala/xml/include/sax/XIncluder.scala
+++ b/shared/src/main/scala/scala/xml/include/sax/XIncluder.scala
@@ -28,9 +28,9 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
 
   var out = new OutputStreamWriter(outs, encoding)
 
-  def setDocumentLocator(locator: Locator): Unit = {}
+  override def setDocumentLocator(locator: Locator): Unit = {}
 
-  def startDocument(): Unit = {
+  override def startDocument(): Unit = {
     try {
       out.write("<?xml version='1.0' encoding='"
         + encoding + "'?>\r\n")
@@ -40,7 +40,7 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
     }
   }
 
-  def endDocument(): Unit = {
+  override def endDocument(): Unit = {
     try {
       out.flush()
     } catch {
@@ -49,11 +49,11 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
     }
   }
 
-  def startPrefixMapping(prefix: String, uri: String): Unit = {}
+  override def startPrefixMapping(prefix: String, uri: String): Unit = {}
 
-  def endPrefixMapping(prefix: String): Unit = {}
+  override def endPrefixMapping(prefix: String): Unit = {}
 
-  def startElement(namespaceURI: String, localName: String, qualifiedName: String, atts: Attributes) = {
+  override def startElement(namespaceURI: String, localName: String, qualifiedName: String, atts: Attributes) = {
     try {
       out.write("<" + qualifiedName)
       var i = 0; while (i < atts.getLength) {
@@ -74,7 +74,7 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
     }
   }
 
-  def endElement(namespaceURI: String, localName: String, qualifiedName: String): Unit = {
+  override def endElement(namespaceURI: String, localName: String, qualifiedName: String): Unit = {
     try {
       out.write("</" + qualifiedName + ">")
     } catch {
@@ -85,7 +85,7 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
 
   // need to escape characters that are not in the given
   // encoding using character references????
-  def characters(ch: Array[Char], start: Int, length: Int): Unit = {
+  override def characters(ch: Array[Char], start: Int, length: Int): Unit = {
     try {
       var i = 0; while (i < length) {
         val c = ch(start + i)
@@ -104,12 +104,12 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
     }
   }
 
-  def ignorableWhitespace(ch: Array[Char], start: Int, length: Int): Unit = {
+  override def ignorableWhitespace(ch: Array[Char], start: Int, length: Int): Unit = {
     this.characters(ch, start, length)
   }
 
   // do I need to escape text in PI????
-  def processingInstruction(target: String, data: String): Unit = {
+  override def processingInstruction(target: String, data: String): Unit = {
     try {
       out.write("<?" + target + " " + data + "?>")
     } catch {
@@ -118,7 +118,7 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
     }
   }
 
-  def skippedEntity(name: String): Unit = {
+  override def skippedEntity(name: String): Unit = {
     try {
       out.write("&" + name + ";")
     } catch {
@@ -131,7 +131,7 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
   private var inDTD: Boolean = false
   private var entities = List.empty[String]
 
-  def startDTD(name: String, publicID: String, systemID: String): Unit = {
+  override def startDTD(name: String, publicID: String, systemID: String): Unit = {
     inDTD = true
     // if this is the source document, output a DOCTYPE declaration
     if (entities.isEmpty) {
@@ -146,18 +146,18 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
       }
     }
   }
-  def endDTD(): Unit = {}
+  override def endDTD(): Unit = {}
 
-  def startEntity(name: String): Unit = {
+  override def startEntity(name: String): Unit = {
     entities =  name :: entities
   }
 
-  def endEntity(name: String): Unit = {
+  override def endEntity(name: String): Unit = {
     entities = entities.tail
   }
 
-  def startCDATA(): Unit = {}
-  def endCDATA(): Unit = {}
+  override def startCDATA(): Unit = {}
+  override def endCDATA(): Unit = {}
 
   // Just need this reference so we can ask if a comment is
   // inside an include element or not
@@ -167,7 +167,7 @@ class XIncluder(outs: OutputStream, encoding: String) extends ContentHandler wit
     this.filter = filter
   }
 
-  def comment(ch: Array[Char], start: Int, length: Int): Unit = {
+  override def comment(ch: Array[Char], start: Int, length: Int): Unit = {
     if (!inDTD && !filter.insideIncludeElement()) {
       try {
         out.write("<!--")
diff --git a/shared/src/main/scala/scala/xml/parsing/ConstructingHandler.scala b/shared/src/main/scala/scala/xml/parsing/ConstructingHandler.scala
index e6355950..4e0000f6 100755
--- a/shared/src/main/scala/scala/xml/parsing/ConstructingHandler.scala
+++ b/shared/src/main/scala/scala/xml/parsing/ConstructingHandler.scala
@@ -22,14 +22,14 @@ package parsing
 abstract class ConstructingHandler extends MarkupHandler {
   val preserveWS: Boolean
 
-  def elem(pos: Int, pre: String, label: String, attrs: MetaData,
+  override def elem(pos: Int, pre: String, label: String, attrs: MetaData,
            pscope: NamespaceBinding, empty: Boolean, nodes: NodeSeq): NodeSeq =
     Elem(pre, label, attrs, pscope, empty, nodes: _*)
 
-  def procInstr(pos: Int, target: String, txt: String) =
+  override def procInstr(pos: Int, target: String, txt: String) =
     ProcInstr(target, txt)
 
-  def comment(pos: Int, txt: String) = Comment(txt)
-  def entityRef(pos: Int, n: String) = EntityRef(n)
-  def text(pos: Int, txt: String) = Text(txt)
+  override def comment(pos: Int, txt: String) = Comment(txt)
+  override def entityRef(pos: Int, n: String) = EntityRef(n)
+  override def text(pos: Int, txt: String) = Text(txt)
 }
diff --git a/shared/src/main/scala/scala/xml/parsing/ConstructingParser.scala b/shared/src/main/scala/scala/xml/parsing/ConstructingParser.scala
index e2f238e5..cbc8aa58 100644
--- a/shared/src/main/scala/scala/xml/parsing/ConstructingParser.scala
+++ b/shared/src/main/scala/scala/xml/parsing/ConstructingParser.scala
@@ -49,7 +49,7 @@ object ConstructingParser {
  * }
  * }}}
  */
-class ConstructingParser(val input: Source, val preserveWS: Boolean)
+class ConstructingParser(override val input: Source, override val preserveWS: Boolean)
   extends ConstructingHandler
   with ExternalSources
   with MarkupParser
diff --git a/shared/src/main/scala/scala/xml/parsing/DefaultMarkupHandler.scala b/shared/src/main/scala/scala/xml/parsing/DefaultMarkupHandler.scala
index c0bf8b72..a8d3b493 100755
--- a/shared/src/main/scala/scala/xml/parsing/DefaultMarkupHandler.scala
+++ b/shared/src/main/scala/scala/xml/parsing/DefaultMarkupHandler.scala
@@ -17,15 +17,15 @@ package parsing
 /** Default implementation of markup handler always returns `NodeSeq.Empty` */
 abstract class DefaultMarkupHandler extends MarkupHandler {
 
-  def elem(pos: Int, pre: String, label: String, attrs: MetaData,
+  override def elem(pos: Int, pre: String, label: String, attrs: MetaData,
            scope: NamespaceBinding, empty: Boolean, args: NodeSeq) = NodeSeq.Empty
 
-  def procInstr(pos: Int, target: String, txt: String) = NodeSeq.Empty
+  override def procInstr(pos: Int, target: String, txt: String) = NodeSeq.Empty
 
-  def comment(pos: Int, comment: String): NodeSeq = NodeSeq.Empty
+  override def comment(pos: Int, comment: String): NodeSeq = NodeSeq.Empty
 
-  def entityRef(pos: Int, n: String) = NodeSeq.Empty
+  override def entityRef(pos: Int, n: String) = NodeSeq.Empty
 
-  def text(pos: Int, txt: String) = NodeSeq.Empty
+  override def text(pos: Int, txt: String) = NodeSeq.Empty
 
 }
diff --git a/shared/src/main/scala/scala/xml/parsing/MarkupParser.scala b/shared/src/main/scala/scala/xml/parsing/MarkupParser.scala
index 4fe936a4..4a9d5352 100755
--- a/shared/src/main/scala/scala/xml/parsing/MarkupParser.scala
+++ b/shared/src/main/scala/scala/xml/parsing/MarkupParser.scala
@@ -33,16 +33,16 @@ import Utility.Escapes.{ pairs => unescape }
 trait MarkupParser extends MarkupParserCommon with TokenTests {
   self: MarkupParser with MarkupHandler =>
 
-  type PositionType = Int
-  type InputType = Source
-  type ElementType = NodeSeq
-  type AttributesType = (MetaData, NamespaceBinding)
-  type NamespaceType = NamespaceBinding
+  override type PositionType = Int
+  override type InputType = Source
+  override type ElementType = NodeSeq
+  override type AttributesType = (MetaData, NamespaceBinding)
+  override type NamespaceType = NamespaceBinding
 
-  def truncatedError(msg: String): Nothing = throw FatalError(msg)
-  def errorNoEnd(tag: String) = throw FatalError("expected closing tag of " + tag)
+  override def truncatedError(msg: String): Nothing = throw FatalError(msg)
+  override def errorNoEnd(tag: String) = throw FatalError("expected closing tag of " + tag)
 
-  def xHandleError(that: Char, msg: String) = reportSyntaxError(msg)
+  override def xHandleError(that: Char, msg: String) = reportSyntaxError(msg)
 
   val input: Source
 
@@ -65,18 +65,18 @@ trait MarkupParser extends MarkupParserCommon with TokenTests {
     private val queue = scala.collection.mutable.Queue[Char]()
     def lookahead(): BufferedIterator[Char] = {
       val iter = queue.iterator ++ new Iterator[Char] {
-        def hasNext = underlying.hasNext
-        def next() = { val x = underlying.next(); queue += x; x }
+        override def hasNext = underlying.hasNext
+        override def next() = { val x = underlying.next(); queue += x; x }
       }
       iter.buffered
     }
-    val iter = new Iterator[Char] {
-      def hasNext = underlying.hasNext || queue.nonEmpty
-      def next() = if (queue.nonEmpty) queue.dequeue() else underlying.next()
+    override val iter = new Iterator[Char] {
+      override def hasNext = underlying.hasNext || queue.nonEmpty
+      override def next() = if (queue.nonEmpty) queue.dequeue() else underlying.next()
     }
   }
 
-  def lookahead(): BufferedIterator[Char] = curInput match {
+  override def lookahead(): BufferedIterator[Char] = curInput match {
     case curInputWLA: WithLookAhead =>
       curInputWLA.lookahead()
     case _ =>
@@ -107,7 +107,7 @@ trait MarkupParser extends MarkupParserCommon with TokenTests {
   var nextChNeeded: Boolean = false
   var reachedEof: Boolean = false
   var lastChRead: Char = _
-  def ch: Char = {
+  override def ch: Char = {
     if (nextChNeeded) {
       if (curInput.hasNext) {
         lastChRead = curInput.next()
@@ -135,7 +135,7 @@ trait MarkupParser extends MarkupParserCommon with TokenTests {
 
   protected var doc: Document = null
 
-  def eof: Boolean = { ch; reachedEof }
+  override def eof: Boolean = { ch; reachedEof }
 
   //
   // methods
@@ -294,17 +294,17 @@ trait MarkupParser extends MarkupParserCommon with TokenTests {
     this
   }
 
-  protected def ch_returning_nextch: Char = { val res = ch; nextch(); res }
+  override protected def ch_returning_nextch: Char = { val res = ch; nextch(); res }
 
-  def mkAttributes(name: String, pscope: NamespaceBinding): AttributesType =
+  override def mkAttributes(name: String, pscope: NamespaceBinding): AttributesType =
     if (isNameStart (ch)) xAttributes(pscope)
     else (Null, pscope)
 
-  def mkProcInstr(position: Int, name: String, text: String): ElementType =
+  override def mkProcInstr(position: Int, name: String, text: String): ElementType =
     handle.procInstr(position, name, text)
 
   /** this method tells ch to get the next character when next called */
-  def nextch(): Unit = {
+  override def nextch(): Unit = {
     // Read current ch if needed
     ch
 
@@ -945,8 +945,8 @@ trait MarkupParser extends MarkupParserCommon with TokenTests {
     handle.notationDecl(notat, extID)
   }
 
-  def reportSyntaxError(pos: Int, str: String): Unit = { curInput.reportError(pos, str) }
-  def reportSyntaxError(str: String): Unit = { reportSyntaxError(pos, str) }
+  override def reportSyntaxError(pos: Int, str: String): Unit = { curInput.reportError(pos, str) }
+  override def reportSyntaxError(str: String): Unit = { reportSyntaxError(pos, str) }
   def reportValidationError(pos: Int, str: String): Unit = { reportSyntaxError(pos, str) }
 
   def push(entityName: String): Unit = {
diff --git a/shared/src/main/scala/scala/xml/parsing/XhtmlParser.scala b/shared/src/main/scala/scala/xml/parsing/XhtmlParser.scala
index 0d2504c8..b21ddec7 100644
--- a/shared/src/main/scala/scala/xml/parsing/XhtmlParser.scala
+++ b/shared/src/main/scala/scala/xml/parsing/XhtmlParser.scala
@@ -22,8 +22,8 @@ import scala.io.Source
  *
  *  @author (c) David Pollak, 2007 WorldWide Conferencing, LLC.
  */
-class XhtmlParser(val input: Source) extends ConstructingHandler with MarkupParser with ExternalSources {
-  val preserveWS = true
+class XhtmlParser(override val input: Source) extends ConstructingHandler with MarkupParser with ExternalSources {
+  override val preserveWS = true
   ent ++= XhtmlEntities()
 }
 
diff --git a/shared/src/main/scala/scala/xml/transform/BasicTransformer.scala b/shared/src/main/scala/scala/xml/transform/BasicTransformer.scala
index c066d52c..397c5fb3 100644
--- a/shared/src/main/scala/scala/xml/transform/BasicTransformer.scala
+++ b/shared/src/main/scala/scala/xml/transform/BasicTransformer.scala
@@ -55,7 +55,7 @@ abstract class BasicTransformer extends Function1[Node, Node] {
     else n
   }
 
-  def apply(n: Node): Node = {
+  override def apply(n: Node): Node = {
     val seq = transform(n)
     if (seq.length > 1)
       throw new UnsupportedOperationException("transform must return single node for root")
diff --git a/shared/src/test/scala/scala/xml/Properties.scala b/shared/src/test/scala/scala/xml/Properties.scala
index 9f4db208..92a81990 100644
--- a/shared/src/test/scala/scala/xml/Properties.scala
+++ b/shared/src/test/scala/scala/xml/Properties.scala
@@ -14,6 +14,6 @@ package scala
 package xml
 
 object Properties extends util.PropertiesTrait {
-  protected def propCategory    = "scala-xml"
-  protected def pickJarBasedOn  = classOf[scala.xml.Node]
+  override protected def propCategory    = "scala-xml"
+  override protected def pickJarBasedOn  = classOf[scala.xml.Node]
 }