Optimize TreePass and Definition hashing for Scala.js performance

Replace HashMap with Stack in TreePass for O(n) tree building.
Add cheap hashCode/equals to Definition trait to avoid O(subtree)
traversal of Contents fields in all HashMap operations. Change
UsageResolution from Seq to mutable.Set for O(1) association lookups.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: reid-spencer

language/shared/src/main/scala/com/ossuminc/riddl/language/AST.scala

@@ -812,6 +812,40 @@ object AST:
     override def isDefinition: Boolean = true
     override def isParent: Boolean = false
     override def hasDefinitions: Boolean = false
+
+    /** Cheap hash based on id + loc to avoid O(subtree) traversal of contents fields.
+      * Case class auto-generated hashCode traverses ALL constructor fields including
+      * Contents (mutable.ArrayBuffer), making every HashMap operation O(subtree).
+      * Note: overriding hashCode here suppresses case class auto-generated equals too
+      * (Scala 3 spec), so we must also override equals to preserve structural comparison.
+      */
+    override def hashCode: Int =
+      val h = id.hashCode * 31 + loc.hashCode
+      h * 31 + getClass.hashCode
+    override def equals(that: Any): Boolean = that match
+      case other: Definition =>
+        (this eq other) || (
+          getClass == other.getClass &&
+          id == other.id &&
+          loc == other.loc &&
+          metadata == other.metadata &&
+          productEquals(other)
+        )
+      case _ => false
+
+    /** Structural comparison of product elements, skipping Contents fields
+      * to avoid O(subtree) traversal. For two Definitions at the same loc
+      * with the same id, the non-contents fields determine equality.
+      */
+    private def productEquals(other: Definition): Boolean =
+      (this, other) match
+        case (a: Product, b: Product) =>
+          a.productArity == b.productArity &&
+          (0 until a.productArity).forall: i =>
+            (a.productElement(i), b.productElement(i)) match
+              case (_: Contents[?], _: Contents[?]) => true // skip contents
+              case (x, y) => x == y
+        case _ => false
   end Definition
 
   object Definition:

passes/shared/src/main/scala/com/ossuminc/riddl/passes/TreePass.scala

@@ -44,8 +44,8 @@ case class TreePass(
 
   def name: String = TreePass.name
 
-  private val childrenMap: mutable.Map[Definition, mutable.ListBuffer[TreeNode]] =
-    mutable.Map.empty
+  private val stack: mutable.Stack[mutable.ListBuffer[TreeNode]] =
+    mutable.Stack.empty
 
   private val topLevel: mutable.ListBuffer[TreeNode] =
     mutable.ListBuffer.empty
@@ -54,7 +54,7 @@ case class TreePass(
     definition: Definition,
     parents: Parents
   ): Unit = {
-    childrenMap(definition) = mutable.ListBuffer.empty
+    stack.push(mutable.ListBuffer.empty)
   }
 
   protected def processLeaf(
@@ -70,11 +70,7 @@ case class TreePass(
         offset = definition.loc.offset,
         children = Seq.empty
       )
-      if parents.nonEmpty then
-        childrenMap.get(parents.head.asInstanceOf[Definition]) match {
-          case Some(buf) => buf.append(leaf)
-          case None      => topLevel.append(leaf)
-        }
+      if stack.nonEmpty then stack.head.append(leaf)
       else topLevel.append(leaf)
       end if
     end if
@@ -89,8 +85,7 @@ case class TreePass(
     definition: Definition,
     parents: Parents
   ): Unit = {
-    val children = childrenMap.remove(definition)
-      .map(_.toSeq).getOrElse(Seq.empty)
+    val children = if stack.nonEmpty then stack.pop().toSeq else Seq.empty
     if definition.id.nonEmpty then
       val node = TreeNode(
         kind = definition.kind,
@@ -100,11 +95,7 @@ case class TreePass(
         offset = definition.loc.offset,
         children = children
       )
-      if parents.nonEmpty then
-        childrenMap.get(parents.head.asInstanceOf[Definition]) match {
-          case Some(buf) => buf.append(node)
-          case None      => topLevel.append(node)
-        }
+      if stack.nonEmpty then stack.head.append(node)
       else topLevel.append(node)
       end if
     end if

passes/shared/src/main/scala/com/ossuminc/riddl/passes/resolve/UsageResolution.scala

@@ -15,11 +15,11 @@ import scala.reflect.ClassTag
 
 trait UsageBase {
 
-  type UseMap = mutable.HashMap[Definition, Seq[Definition]]
-  type UsedByMap = mutable.HashMap[Definition, Seq[Definition]]
+  type UseMap = mutable.HashMap[Definition, mutable.Set[Definition]]
+  type UsedByMap = mutable.HashMap[Definition, mutable.Set[Definition]]
 
-  protected val uses: UseMap = mutable.HashMap.empty[Definition, Seq[Definition]]
-  protected val usedBy: UsedByMap = mutable.HashMap.empty[Definition, Seq[Definition]]
+  protected val uses: UseMap = mutable.HashMap.empty[Definition, mutable.Set[Definition]]
+  protected val usedBy: UsedByMap = mutable.HashMap.empty[Definition, mutable.Set[Definition]]
 }
 
 /** Validation State for Uses/UsedBy Tracking. During parsing, when usage is detected, call associateUsage. After
@@ -60,11 +60,8 @@ trait UsageResolution(using io: PlatformContext) extends UsageBase {
   end associateUsage
 
   def associateUsage(user: Definition, use: Definition): this.type =
-    val used = uses.getOrElse(user, Seq.empty[Definition])
-    if !used.contains(use) then uses.update(user, used :+ use)
-
-    val usages = usedBy.getOrElse(use, Seq.empty[Definition])
-    if !usages.contains(user) then usedBy.update(use, usages :+ user)
+    uses.getOrElseUpdate(user, mutable.Set.empty[Definition]).add(use)
+    usedBy.getOrElseUpdate(use, mutable.Set.empty[Definition]).add(user)
     this
   end associateUsage
 

passes/shared/src/main/scala/com/ossuminc/riddl/passes/resolve/Usages.scala

@@ -31,7 +31,7 @@ case class Usages(
 
   /** Determine if a definition is used or not */
   def isUsed(definition: Definition): Boolean = {
-    uses.keys.exists(_ == definition)
+    uses.contains(definition)
   }
 
   /** Determine if one definition is used by another
@@ -72,7 +72,7 @@ case class Usages(
     *   The [[scala.Seq]] of [[com.ossuminc.riddl.language.AST.Definition]] that are using `used`
     */
   def getUsers(used: Definition): Seq[Definition] = {
-    usedBy.getOrElse(used, Seq.empty)
+    usedBy.getOrElse(used, mutable.Set.empty).toSeq
   }
 
   /** Retrieve the uses of a given user
@@ -83,7 +83,7 @@ case class Usages(
     *   The [[scala.Seq]] of [[com.ossuminc.riddl.language.AST.Definition]] that are used by `user`
     */
   def getUses(user: Definition): Seq[Definition] = {
-    uses.getOrElse(user, Seq.empty)
+    uses.getOrElse(user, mutable.Set.empty).toSeq
   }
 
   def usesAsString: String = {