More simplification

Author: SolalPirelli

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -7157,7 +7157,7 @@ object Types extends TypeUtils {
 
   object VarianceMap:
     /** An immutable map representing the variance of keys of type `K` */
-    opaque type VarianceMap[K <: AnyRef] <: AnyRef = SimpleIdentityMap[K, Integer]
+    opaque type VarianceMap[K <: AnyRef] = SimpleIdentityMap[K, Integer]
     def empty[K <: AnyRef]: VarianceMap[K] = SimpleIdentityMap.empty[K]
     extension [K <: AnyRef](vmap: VarianceMap[K])
       /** The backing map used to implement this VarianceMap. */

compiler/src/dotty/tools/dotc/inlines/Inliner.scala

@@ -1220,7 +1220,7 @@ class Inliner(val call: tpd.Tree)(using Context):
     // inlining.println(i"drop unused $bindings%, % in $tree")
     val (termBindings, typeBindings) = bindings.partition(_.symbol.isTerm)
     if (typeBindings.nonEmpty) {
-      val typeBindingsSet = typeBindings.foldLeft[SimpleIdentitySet[Symbol]](SimpleIdentitySet.empty)(_ + _.symbol)
+      val typeBindingsSet = SimpleIdentitySet(typeBindings.iterator.map(_.symbol))
       val inlineTypeBindings = new TreeTypeMap(
         typeMap = new TypeMap() {
           override def apply(tp: Type): Type = tp match {

compiler/src/dotty/tools/dotc/typer/Inferencing.scala

@@ -590,7 +590,7 @@ object Inferencing {
               constraint.upper(param).foreach(p => traverse(constraint.typeVarOfParam(p)))
           case _ =>
       }
-      if (vmap1 eq vmap) vmap else propagate(vmap1)
+      if (vmap1 == vmap) vmap else propagate(vmap1)
     }
 
     propagate(accu(accu(VarianceMap.empty, tp), pt.finalResultType))
@@ -669,7 +669,7 @@ trait Inferencing { this: Typer =>
     // `qualifying`.
 
     val ownedVars = state.ownedVars
-    if (ownedVars ne locked) && !ownedVars.isEmpty then
+    if (ownedVars != locked) && !ownedVars.isEmpty then
       val qualifying = (ownedVars -- locked).toList
       if (!qualifying.isEmpty) {
         typr.println(i"interpolate $tree: ${tree.tpe.widen} in $state, pt = $pt, owned vars = ${state.ownedVars.toList}%, %, qualifying = ${qualifying.toList}%, %, previous = ${locked.toList}%, % / ${state.constraint}")
@@ -748,7 +748,7 @@ trait Inferencing { this: Typer =>
     end toInstantiate
 
     def typeVarsIn(xs: ToInstantiate): TypeVars =
-      xs.foldLeft(SimpleIdentitySet.empty: TypeVars)((tvs, tvi) => tvs + tvi._1)
+      SimpleIdentitySet(xs.iterator.map(_._1))
 
     /** Filter list of proposed instantiations so that they don't constrain further
      *  the current constraint.

compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala

@@ -5,7 +5,7 @@ import scala.collection.mutable.ListBuffer
 /** A simple linked map with `eq` as the key comparison, optimized for small maps.
  * It has linear complexity for `apply`, `updated`, and `remove`.
  */
-final class SimpleIdentityMap[K <: AnyRef, +V <: AnyRef](bindings: Array[AnyRef]) extends (K => V | Null) {
+final class SimpleIdentityMap[K <: AnyRef, +V <: AnyRef](bindings: Array[AnyRef]) extends AnyVal {
   private def key(i: Int): K = bindings(i).asInstanceOf[K]
 
   private def value(i: Int): V = bindings(i + 1).asInstanceOf[V]
@@ -15,7 +15,7 @@ final class SimpleIdentityMap[K <: AnyRef, +V <: AnyRef](bindings: Array[AnyRef]
 
   def size: Int = bindings.length / 2
 
-  Stats.record(s"SimpleIdentityMap/$size")
+  //Stats.record(s"SimpleIdentityMap/$size")
 
   def apply(k: K): V | Null = {
     var i = 0
@@ -122,7 +122,7 @@ final class SimpleIdentityMap[K <: AnyRef, +V <: AnyRef](bindings: Array[AnyRef]
 
   def toList: List[(K, V)] = map2((k, v) => (k, v))
 
-  override def toString(): String = {
+  override def toString: String = {
     def assocToString(key: K, value: V) = s"$key -> $value"
 
     map2(assocToString) mkString("(", ", ", ")")

compiler/src/dotty/tools/dotc/util/SimpleIdentitySet.scala

@@ -5,7 +5,7 @@ import collection.mutable
 /** A simple linked set with `eq` as the comparison, optimized for small sets.
  * It has linear complexity for `contains`, `+`, and `-`.
  */
-final class SimpleIdentitySet[+Elem <: AnyRef](val xs: Array[AnyRef]) {
+final class SimpleIdentitySet[+Elem <: AnyRef](private val xs: Array[AnyRef]) {
   def size: Int = xs.length
 
   def +[E >: Elem <: AnyRef](x: E): SimpleIdentitySet[E] =
@@ -144,7 +144,7 @@ final class SimpleIdentitySet[+Elem <: AnyRef](val xs: Array[AnyRef]) {
     else this.filter(that.contains)
 
   def ==[E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): Boolean =
-    (this eq that) || this.size == that.size && forall(that.contains)
+    (this.xs eq that.xs) || this.size == that.size && forall(that.contains)
 
   def !=[E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): Boolean =
     !(this == that)
@@ -156,7 +156,10 @@ object SimpleIdentitySet {
   private val emptySet = new SimpleIdentitySet(Array.empty[AnyRef])
 
   def apply[Elem <: AnyRef](elems: Elem*): SimpleIdentitySet[Elem] =
-    elems.foldLeft(empty: SimpleIdentitySet[Elem])(_ + _)
+    new SimpleIdentitySet[Elem](elems.toArray)
+
+  def apply[Elem <: AnyRef](elems: Iterator[Elem]): SimpleIdentitySet[Elem] =
+    new SimpleIdentitySet[Elem](elems.toArray)
 
   extension [E <: AnyRef](xs: SimpleIdentitySet[E])
     def intersect(ys: SimpleIdentitySet[E]): SimpleIdentitySet[E] =