chore: port all hashCode method in the Scala 2 inherited stdlib to be nullary functions

hamzaremmal · hamzaremmal · commit 45f2f40639f9 · 2025-11-17T19:28:48.000+01:00
diff --git a/library/src/scala/Enumeration.scala b/library/src/scala/Enumeration.scala
@@ -98,11 +98,11 @@ abstract class Enumeration (initial: Int) extends Serializable {
 
   /** The name of this enumeration.
    */
-  override def toString: String =
+  override def toString(): String =
     getClass.getName
       .stripSuffix(MODULE_SUFFIX_STRING)
       .split('.')
-      .last 
+      .last
       .split(Regex.quote(NAME_JOIN_STRING))
       .last
 
@@ -241,7 +241,7 @@ abstract class Enumeration (initial: Int) extends Serializable {
       case that: Enumeration#Value  => (outerEnum eq that.outerEnum) && (id == that.id)
       case _                        => false
     }
-    override def hashCode: Int = id.##
+    override def hashCode(): Int = id.##
 
     /** Create a ValueSet which contains this value and another one */
     def + (v: Value): ValueSet = ValueSet(this, v)
diff --git a/library/src/scala/Proxy.scala b/library/src/scala/Proxy.scala
@@ -29,7 +29,7 @@ import scala.language.`2.13`
 trait Proxy extends Any {
   def self: Any
 
-  override def hashCode: Int = self.hashCode
+  override def hashCode(): Int = self.hashCode
   override def equals(that: Any): Boolean = that match {
     case null  => false
     case _     =>
diff --git a/library/src/scala/Symbol.scala b/library/src/scala/Symbol.scala
@@ -24,7 +24,7 @@ final class Symbol private (val name: String) extends Serializable {
 
   @throws(classOf[java.io.ObjectStreamException])
   private def readResolve(): Any = Symbol.apply(name)
-  override def hashCode = name.hashCode()
+  override def hashCode() = name.hashCode()
   override def equals(other: Any) = this eq other.asInstanceOf[AnyRef]
 }
 
diff --git a/library/src/scala/collection/Iterator.scala b/library/src/scala/collection/Iterator.scala
@@ -898,7 +898,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
       // to verify partnerhood we use reference equality on gap because
       // type testing does not discriminate based on origin.
       private def compareGap(queue: scala.collection.mutable.Queue[A]) = gap eq queue
-      override def hashCode = gap.hashCode()
+      override def hashCode() = gap.hashCode()
       override def equals(other: Any) = other match {
         case x: Partner   => x.compareGap(gap) && gap.isEmpty
         case _            => super.equals(other)
diff --git a/library/src/scala/collection/convert/JavaCollectionWrappers.scala b/library/src/scala/collection/convert/JavaCollectionWrappers.scala
@@ -41,7 +41,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
       case that: IteratorWrapper[_] => this.underlying == that.underlying
       case _ => false
     }
-    override def hashCode: Int = underlying.hashCode()
+    override def hashCode(): Int = underlying.hashCode()
   }
 
   @SerialVersionUID(3L)
@@ -52,7 +52,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
       case that: JIteratorWrapper[_] => this.underlying == that.underlying
       case _ => false
     }
-    override def hashCode: Int = underlying.hashCode()
+    override def hashCode(): Int = underlying.hashCode()
   }
 
   @SerialVersionUID(3L)
@@ -63,7 +63,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
       case that: JEnumerationWrapper[_] => this.underlying == that.underlying
       case _ => false
     }
-    override def hashCode: Int = underlying.hashCode()
+    override def hashCode(): Int = underlying.hashCode()
   }
 
   trait IterableWrapperTrait[A] extends ju.AbstractCollection[A] {
@@ -79,7 +79,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
       case that: IterableWrapper[_] => this.underlying == that.underlying
       case _ => false
     }
-    override def hashCode: Int = underlying.hashCode()
+    override def hashCode(): Int = underlying.hashCode()
   }
 
   @SerialVersionUID(3L)
@@ -94,7 +94,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
       case that: JIterableWrapper[_] => this.underlying == that.underlying
       case _ => false
     }
-    override def hashCode: Int = underlying.hashCode()
+    override def hashCode(): Int = underlying.hashCode()
   }
 
   @SerialVersionUID(3L)
@@ -111,7 +111,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
       case that: JCollectionWrapper[_] => this.underlying == that.underlying
       case _ => false
     }
-    override def hashCode: Int = underlying.hashCode()
+    override def hashCode(): Int = underlying.hashCode()
   }
 
   @SerialVersionUID(3L)
@@ -285,7 +285,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
             // specified in the javadocs of java.util.Map.Entry.hashCode
             //
             // See https://github.com/scala/bug/issues/10663
-            override def hashCode = {
+            override def hashCode() = {
               (if (k == null) 0 else k.hashCode()) ^
               (if (v == null) 0 else v.hashCode())
             }
@@ -552,7 +552,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {
       case _ => false
     }
 
-    override def hashCode: Int = underlying.hashCode()
+    override def hashCode(): Int = underlying.hashCode()
   }
 
   @SerialVersionUID(3L)
diff --git a/library/src/scala/collection/immutable/ArraySeq.scala b/library/src/scala/collection/immutable/ArraySeq.scala
@@ -332,7 +332,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): T = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any): Boolean = that match {
       case that: ofRef[_] =>
         Array.equals(
@@ -363,7 +363,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Byte = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofByte => Arrays.equals(unsafeArray, that.unsafeArray)
       case _ => super.equals(that)
@@ -405,7 +405,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Short = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofShort => Arrays.equals(unsafeArray, that.unsafeArray)
       case _ => super.equals(that)
@@ -447,7 +447,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Char = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofChar => Arrays.equals(unsafeArray, that.unsafeArray)
       case _ => super.equals(that)
@@ -492,7 +492,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Int = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofInt => Arrays.equals(unsafeArray, that.unsafeArray)
       case _ => super.equals(that)
@@ -534,7 +534,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Long = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofLong => Arrays.equals(unsafeArray, that.unsafeArray)
       case _ => super.equals(that)
@@ -576,7 +576,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Float = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofFloat =>
         val array = unsafeArray
@@ -618,7 +618,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Double = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofDouble =>
         val array = unsafeArray
@@ -660,7 +660,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Boolean = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofBoolean => Arrays.equals(unsafeArray, that.unsafeArray)
       case _ => super.equals(that)
@@ -699,7 +699,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = unsafeArray.length
     @throws[ArrayIndexOutOfBoundsException]
     def apply(i: Int): Unit = unsafeArray(i)
-    override def hashCode = MurmurHash3.arraySeqHash(unsafeArray)
+    override def hashCode() = MurmurHash3.arraySeqHash(unsafeArray)
     override def equals(that: Any) = that match {
       case that: ofUnit => unsafeArray.length == that.unsafeArray.length
       case _ => super.equals(that)
diff --git a/library/src/scala/collection/immutable/Range.scala b/library/src/scala/collection/immutable/Range.scala
@@ -527,7 +527,7 @@ sealed abstract class Range(
       super.equals(other)
   }
 
-  final override def hashCode: Int =
+  final override def hashCode(): Int =
     if(length >= 2) MurmurHash3.rangeHash(start, step, lastElement)
     else super.hashCode
 
diff --git a/library/src/scala/collection/mutable/ArraySeq.scala b/library/src/scala/collection/mutable/ArraySeq.scala
@@ -143,7 +143,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): T = array(index)
     def update(index: Int, elem: T): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofRef[_] =>
         Array.equals(
@@ -166,7 +166,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Byte = array(index)
     def update(index: Int, elem: Byte): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofByte => Arrays.equals(array, that.array)
       case _ => super.equals(that)
@@ -186,7 +186,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Short = array(index)
     def update(index: Int, elem: Short): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofShort => Arrays.equals(array, that.array)
       case _ => super.equals(that)
@@ -206,7 +206,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Char = array(index)
     def update(index: Int, elem: Char): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofChar => Arrays.equals(array, that.array)
       case _ => super.equals(that)
@@ -247,7 +247,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Int = array(index)
     def update(index: Int, elem: Int): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofInt => Arrays.equals(array, that.array)
       case _ => super.equals(that)
@@ -267,7 +267,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Long = array(index)
     def update(index: Int, elem: Long): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofLong => Arrays.equals(array, that.array)
       case _ => super.equals(that)
@@ -287,7 +287,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Float = array(index)
     def update(index: Int, elem: Float): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofFloat =>
         val thatArray = that.array
@@ -313,7 +313,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Double = array(index)
     def update(index: Int, elem: Double): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofDouble =>
         val thatArray = that.array
@@ -339,7 +339,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Boolean = array(index)
     def update(index: Int, elem: Boolean): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofBoolean => Arrays.equals(array, that.array)
       case _ => super.equals(that)
@@ -356,7 +356,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
     def length: Int = array.length
     def apply(index: Int): Unit = array(index)
     def update(index: Int, elem: Unit): Unit = { array(index) = elem }
-    override def hashCode = MurmurHash3.arraySeqHash(array)
+    override def hashCode() = MurmurHash3.arraySeqHash(array)
     override def equals(that: Any) = that match {
       case that: ofUnit => array.length == that.array.length
       case _ => super.equals(that)
diff --git a/library/src/scala/collection/mutable/HashMap.scala b/library/src/scala/collection/mutable/HashMap.scala
@@ -578,12 +578,12 @@ class HashMap[K, V](initialCapacity: Int, loadFactor: Double)
   @nowarn("""cat=deprecation&origin=scala\.collection\.Iterable\.stringPrefix""")
   override protected def stringPrefix = "HashMap"
 
-  override def hashCode: Int = {
+  override def hashCode(): Int = {
     if (isEmpty) MurmurHash3.emptyMapHash
     else {
       val tupleHashIterator = new HashMapIterator[Any] {
         var hash: Int = 0
-        override def hashCode: Int = hash
+        override def hashCode(): Int = hash
         override protected def extract(nd: Node[K, V]): Any = {
           hash = MurmurHash3.tuple2Hash(unimproveHash(nd.hash), nd.value.##)
           this
diff --git a/library/src/scala/collection/mutable/HashSet.scala b/library/src/scala/collection/mutable/HashSet.scala
@@ -385,13 +385,13 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double)
 
   override protected def className = "HashSet"
 
-  override def hashCode: Int = {
+  override def hashCode(): Int = {
     val setIterator = this.iterator
     val hashIterator: Iterator[Any] =
       if (setIterator.isEmpty) setIterator
       else new HashSetIterator[Any] {
         var hash: Int = 0
-        override def hashCode: Int = hash
+        override def hashCode(): Int = hash
         override protected def extract(nd: Node[A]): Any = {
           hash = unimproveHash(nd.hash)
           this
diff --git a/library/src/scala/collection/mutable/LinkedHashMap.scala b/library/src/scala/collection/mutable/LinkedHashMap.scala
@@ -455,12 +455,12 @@ class LinkedHashMap[K, V]
     }
   }
 
-  override def hashCode: Int = {
+  override def hashCode(): Int = {
     if (isEmpty) MurmurHash3.emptyMapHash
     else {
       val tupleHashIterator = new LinkedHashMapIterator[Any] {
         var hash: Int = 0
-        override def hashCode: Int = hash
+        override def hashCode(): Int = hash
         override def extract(nd: Entry): Any = {
           hash = MurmurHash3.tuple2Hash(unimproveHash(nd.hash), nd.value.##)
           this
diff --git a/library/src/scala/collection/mutable/LinkedHashSet.scala b/library/src/scala/collection/mutable/LinkedHashSet.scala
@@ -291,13 +291,13 @@ class LinkedHashSet[A]
     }
   }
 
-  override def hashCode: Int = {
+  override def hashCode(): Int = {
     val setHashIterator =
       if (isEmpty) this.iterator
       else {
         new LinkedHashSetIterator[Any] {
           var hash: Int = 0
-          override def hashCode: Int = hash
+          override def hashCode(): Int = hash
           override def extract(nd: Entry): Any = {
             hash = unimproveHash(nd.hash)
             this
diff --git a/library/src/scala/concurrent/duration/Duration.scala b/library/src/scala/concurrent/duration/Duration.scala
@@ -739,5 +739,5 @@ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duratio
     case x: FiniteDuration => toNanos == x.toNanos
     case _                 => super.equals(other)
   }
-  override def hashCode: Int = toNanos.toInt
+  override def hashCode(): Int = toNanos.toInt
 }
diff --git a/library/src/scala/reflect/ClassTag.scala b/library/src/scala/reflect/ClassTag.scala
@@ -81,7 +81,7 @@ trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serial
   // case class accessories
   override def canEqual(x: Any) = x.isInstanceOf[ClassTag[?]]
   override def equals(x: Any) = x.isInstanceOf[ClassTag[?]] && this.runtimeClass == x.asInstanceOf[ClassTag[?]].runtimeClass
-  override def hashCode = runtimeClass.##
+  override def hashCode() = runtimeClass.##
   override def toString() = {
     def prettyprint(clazz: jClass[?]): String =
       if (clazz.isArray) s"Array[${prettyprint(clazz.getComponentType)}]" else
diff --git a/library/src/scala/reflect/Manifest.scala b/library/src/scala/reflect/Manifest.scala
@@ -65,7 +65,7 @@ trait Manifest[T] extends ClassManifest[T] with Equals {
     case m: Manifest[_] => (m canEqual this) && (this.runtimeClass == m.runtimeClass) && (this <:< m) && (m <:< this)
     case _              => false
   }
-  override def hashCode = this.runtimeClass.##
+  override def hashCode() = this.runtimeClass.##
 }
 
 /** The object `Manifest` defines factory methods for manifests.

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ final class Symbol private (val name: String) extends Serializable {`
`24`	`24`
`25`	`25`	`@throws(classOf[java.io.ObjectStreamException])`
`26`	`26`	`private def readResolve(): Any = Symbol.apply(name)`
`27`		`- override def hashCode = name.hashCode()`
	`27`	`+ override def hashCode() = name.hashCode()`
`28`	`28`	`override def equals(other: Any) = this eq other.asInstanceOf[AnyRef]`
`29`	`29`	`}`
`30`	`30`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`41`	`41`	`case that: IteratorWrapper[_] => this.underlying == that.underlying`
`42`	`42`	`case _ => false`
`43`	`43`	`}`
`44`		`- override def hashCode: Int = underlying.hashCode()`
	`44`	`+ override def hashCode(): Int = underlying.hashCode()`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`@SerialVersionUID(3L)`
`@@ -52,7 +52,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`52`	`52`	`case that: JIteratorWrapper[_] => this.underlying == that.underlying`
`53`	`53`	`case _ => false`
`54`	`54`	`}`
`55`		`- override def hashCode: Int = underlying.hashCode()`
	`55`	`+ override def hashCode(): Int = underlying.hashCode()`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`@SerialVersionUID(3L)`
`@@ -63,7 +63,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`63`	`63`	`case that: JEnumerationWrapper[_] => this.underlying == that.underlying`
`64`	`64`	`case _ => false`
`65`	`65`	`}`
`66`		`- override def hashCode: Int = underlying.hashCode()`
	`66`	`+ override def hashCode(): Int = underlying.hashCode()`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`trait IterableWrapperTrait[A] extends ju.AbstractCollection[A] {`
`@@ -79,7 +79,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`79`	`79`	`case that: IterableWrapper[_] => this.underlying == that.underlying`
`80`	`80`	`case _ => false`
`81`	`81`	`}`
`82`		`- override def hashCode: Int = underlying.hashCode()`
	`82`	`+ override def hashCode(): Int = underlying.hashCode()`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`@SerialVersionUID(3L)`
`@@ -94,7 +94,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`94`	`94`	`case that: JIterableWrapper[_] => this.underlying == that.underlying`
`95`	`95`	`case _ => false`
`96`	`96`	`}`
`97`		`- override def hashCode: Int = underlying.hashCode()`
	`97`	`+ override def hashCode(): Int = underlying.hashCode()`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`@SerialVersionUID(3L)`
`@@ -111,7 +111,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`111`	`111`	`case that: JCollectionWrapper[_] => this.underlying == that.underlying`
`112`	`112`	`case _ => false`
`113`	`113`	`}`
`114`		`- override def hashCode: Int = underlying.hashCode()`
	`114`	`+ override def hashCode(): Int = underlying.hashCode()`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`@SerialVersionUID(3L)`
`@@ -285,7 +285,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`285`	`285`	`// specified in the javadocs of java.util.Map.Entry.hashCode`
`286`	`286`	`//`
`287`	`287`	`// See https://github.com/scala/bug/issues/10663`
`288`		`- override def hashCode = {`
	`288`	`+ override def hashCode() = {`
`289`	`289`	`(if (k == null) 0 else k.hashCode()) ^`
`290`	`290`	`(if (v == null) 0 else v.hashCode())`
`291`	`291`	`}`
`@@ -552,7 +552,7 @@ private[collection] object JavaCollectionWrappers extends Serializable {`
`552`	`552`	`case _ => false`
`553`	`553`	`}`
`554`	`554`
`555`		`- override def hashCode: Int = underlying.hashCode()`
	`555`	`+ override def hashCode(): Int = underlying.hashCode()`
`556`	`556`	`}`
`557`	`557`
`558`	`558`	`@SerialVersionUID(3L)`
Original file line number	Diff line number	Diff line change
`@@ -527,7 +527,7 @@ sealed abstract class Range(`
`527`	`527`	`super.equals(other)`
`528`	`528`	`}`
`529`	`529`
`530`		`- final override def hashCode: Int =`
	`530`	`+ final override def hashCode(): Int =`
`531`	`531`	`if(length >= 2) MurmurHash3.rangeHash(start, step, lastElement)`
`532`	`532`	`else super.hashCode`
`533`	`533`