small perf improvements in ProtoToGraphNodeMappings and ZipArchive (#1800)

* ProtoToGraphNodeMappings: use mutable datastructures internally

the immmutable maps have some unneccessary overhead

* ZipArchive: don't return results as linked list

Author: maltek

codepropertygraph/src/main/scala/io/shiftleft/codepropertygraph/cpgloading/ProtoToGraphNodeMappings.scala

@@ -3,36 +3,21 @@ package io.shiftleft.codepropertygraph.cpgloading
 import flatgraph.*
 import io.shiftleft.proto.cpg.Cpg.CpgStruct
 
+import scala.collection.mutable
 import scala.jdk.CollectionConverters.*
 
-/** Mutable datastructure to preserve mapping between proto and cpg nodes during ProtoToCpg import.
+/** Mutable data structure to preserve mapping between proto and cpg nodes during ProtoToCpg import.
   *
   * Context: we need to run two passes: 1) add nodes and 2) set node properties and add edges (this is due to
   * flatgraph-specific implementation details)
   *
-  * Because of that, we need to remember the mapping from proto node id to gnode. Typically that's just a plain mapping,
-  * but there's one special case for TYPE nodes: some (parallel) frontends create duplicate TYPE nodes which we need to
-  * deduplicate...
+  * Because of that, we need to remember the mapping from proto node id to gnode. Typically, that's just a plain
+  * mapping. But there's one special case for TYPE nodes: some (parallel) frontends create duplicate TYPE nodes which we
+  * need to deduplicate...
   */
 class ProtoToGraphNodeMappings {
-  private var protoNodeIdToGNode  = Map.empty[Long, DNode]
-  private var typeFullNameToGNode = Map.empty[String, DNode]
-
-  def addAll(other: ProtoToGraphNodeMappings): Unit = {
-    val intersection1 = this.protoNodeIdToGNode.keySet.intersect(other.protoNodeIdToGNode.keySet)
-    val intersection2 = this.typeFullNameToGNode.keySet.intersect(other.typeFullNameToGNode.keySet)
-    assert(
-      intersection1.isEmpty,
-      s"unexpected duplicate entries in protoNodeIdToGNode mappings. protoNodeIds: $intersection1"
-    )
-    assert(
-      intersection2.isEmpty,
-      s"unexpected duplicate entries in typeFullNameToGNode mappings. FullNames: $intersection2"
-    )
-
-    this.protoNodeIdToGNode = this.protoNodeIdToGNode ++ other.protoNodeIdToGNode
-    this.typeFullNameToGNode = this.typeFullNameToGNode ++ other.typeFullNameToGNode
-  }
+  private val protoNodeIdToGNode  = mutable.LongMap.empty[DNode]
+  private val typeFullNameToGNode = mutable.Map.empty[String, DNode]
 
   def add(protoNode: CpgStruct.Node, node: DNode): Unit = {
     protoNodeIdToGNode += protoNode.getKey -> node
@@ -48,7 +33,7 @@ class ProtoToGraphNodeMappings {
     }
   }
 
-  /** This will fail hard if the DiffGraph hasn't been applied yet, which is the assumption for it's use case. In other
+  /** This will fail hard if the DiffGraph hasn't been applied yet, which is the assumption for its use case. In other
     * words, we specifically don't want to invoke `find(protoNode).flatMap(_.storedRef)` here
     */
   def findGNode(protoNode: CpgStruct.Node): Option[GNode] =

codepropertygraph/src/main/scala/io/shiftleft/codepropertygraph/cpgloading/ZipArchive.scala

@@ -2,18 +2,19 @@ package io.shiftleft.codepropertygraph.cpgloading
 
 import java.io.Closeable
 import java.nio.file.attribute.BasicFileAttributes
-import java.nio.file.{FileSystem, FileSystems, FileVisitResult, Files, Path, Paths, SimpleFileVisitor}
-import java.util.{Collection => JCollection}
+import java.nio.file.{FileSystem, FileSystems, FileVisitOption, FileVisitResult, Files, Path, Paths, SimpleFileVisitor}
+import java.util.Collection as JCollection
+import scala.collection.immutable.ArraySeq
 import scala.collection.mutable.ArrayBuffer
-import scala.jdk.CollectionConverters._
+import scala.jdk.CollectionConverters.*
 
 class ZipArchive(inputFile: String) extends Closeable {
   private val zipFileSystem: FileSystem = FileSystems.newFileSystem(Paths.get(inputFile), null: ClassLoader)
 
   private def root: Path = zipFileSystem.getRootDirectories.iterator.next
 
   private def walk(rootPath: Path): Seq[Path] = {
-    val entries = ArrayBuffer[Path]()
+    val entries = ArraySeq.newBuilder[Path]()
     Files.walkFileTree(
       rootPath,
       new SimpleFileVisitor[Path]() {
@@ -24,7 +25,7 @@ class ZipArchive(inputFile: String) extends Closeable {
         }
       }
     )
-    entries.toSeq
+    entries.result()
   }
 
   def entries: Seq[Path] = walk(root)