scala-wasm
diff --git a/‎project/JavalibIRCleaner.scala
Lines changed: 36 additions & 41 deletions b/‎project/JavalibIRCleaner.scala
Lines changed: 36 additions & 41 deletions
@@ -13,9 +13,11 @@ import java.net.URI
 import java.nio._
 import java.nio.file._
 import java.nio.file.attribute._
+import java.util.stream.{Stream, StreamSupport}
 
 import scala.collection.immutable.IndexedSeq
 import scala.collection.mutable
+import scala.collection.JavaConverters._
 
 import sbt.{Logger, MessageOnlyException}
 
@@ -43,6 +45,8 @@ import sbt.{Logger, MessageOnlyException}
 final class JavalibIRCleaner(baseDirectoryURI: URI) {
   import JavalibIRCleaner._
 
+  type JSTypes = Map[ClassName, Option[JSNativeLoadSpec]]
+
   def cleanIR(dependencyFiles: Seq[File], libFileMappings: Seq[(File, File)],
       logger: Logger): Set[File] = {
 
@@ -55,14 +59,16 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
     }
 
     val jsTypes = {
-      val dependencyIR = dependencyFiles.iterator.flatMap { file =>
-        if (file.getName().endsWith(".jar"))
-          readIRJar(file)
-        else
-          List(readIR(file))
+      val dependencyIR: Stream[ClassDef] = {
+        dependencyFiles.asJava.stream().flatMap { file =>
+          if (file.getName().endsWith(".jar"))
+            readIRJar(file)
+          else
+            Stream.of[ClassDef](readIR(file))
+        }
       }
-      val libIR = libIRMappings.iterator.map(_._1)
-      getJSTypes(dependencyIR ++ libIR)
+      val libIR: Stream[ClassDef] = libIRMappings.asJava.stream().map(_._1)
+      getJSTypes(Stream.concat(dependen
10000
cyIR, libIR))
     }
 
     val resultBuilder = Set.newBuilder[File]
@@ -123,31 +129,21 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
     Serializers.deserialize(buffer)
   }
 
-  private def readIRJar(jar: File): List[ClassDef] = {
-    // Similar to PathIRContainer.JarIRContainer and its walkIR helper
-
-    val classDefs = List.newBuilder[ClassDef]
-
-    val dirVisitor = new SimpleFileVisitor[Path] {
-      override def visitFile(path: Path, attrs: BasicFileAttributes): FileVisitResult = {
-        if (path.getFileName().toString().endsWith(".sjsir"))
-          classDefs += readIR(path)
-        super.visitFile(path, attrs)
-      }
+  private def readIRJar(jar: File): Stream[ClassDef] = {
+    def isIRFile(path: Path) = {
+      val fn = path.getFileName() // null if path is FS root
+      fn != null && fn.toString().endsWith(".sjsir")
     }
 
     // Open zip/jar file as filesystem.
     // The type ascription is necessary on JDK 13+.
     val fs = FileSystems.newFileSystem(jar.toPath(), null: ClassLoader)
-    try {
-      val iter = fs.getRootDirectories().iterator()
-      while (iter.hasNext())
-        Files.walkFileTree(iter.next(), dirVisitor)
-    } finally {
-      fs.close()
-    }
-
-    classDefs.result()
+    StreamSupport
+      .stream(fs.getRootDirectories().spliterator(), /* parallel= */ false)
+      .flatMap(Files.walk(_))
+      .filter(isIRFile(_))
+      .map[ClassDef](readIR(_))
+      .onClose(() => fs.close()) // only close fs once all IR is read.
   }
 
   private def writeIRFile(file: File, tree: ClassDef): Unit = {
@@ -161,17 +157,19 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
     }
   }
 
-  private def getJSTypes(trees: Iterator[ClassDef]): Map[ClassName, ClassDef] =
-    trees.filter(_.kind.isJSType).map(t => t.className -> t).toMap
+  private def getJSTypes(trees: Stream[ClassDef]): JSTypes = {
+    trees.filter(_.kind.isJSType).reduce[JSTypes](
+        Map.empty, (m, v) => m.updated(v.className, v.jsNativeLoadSpec), _ ++ _)
+  }
 
-  private def cleanTree(tree: ClassDef, jsTypes: Map[ClassName, ClassDef],
+  private def cleanTree(tree: ClassDef, jsTypes: JSTypes,
       errorManager: ErrorManager): ClassDef = {
     new ClassDefCleaner(tree.className, jsTypes, errorManager)
       .cleanClassDef(tree)
   }
 
   private final class ClassDefCleaner(enclosingClassName: ClassName,
-      jsTypes: Map[ClassName, ClassDef], errorManager: ErrorManager)
+      jsTypes: JSTypes, errorManager: ErrorManager)
       extends Transformers.ClassTransformer {
 
     def cleanClassDef(tree: ClassDef): ClassDef = {
@@ -500,16 +498,13 @@ final class JavalibIRCleaner(baseDirectoryURI: URI) {
     private def genLoadFromLoadSpecOf(className: ClassName)(
         implicit pos: Position): Tree = {
       jsTypes.get(className) match {
-        case Some(classDef) =>
-          classDef.jsNativeLoadSpec match {
-            case Some(loadSpec) =>
-              genLoadFromLoadSpec(loadSpec)
-            case None =>
-              reportError(
-                  s"${className.nameString} does not have a load spec " +
-                  "(this shouldn't have happened at all; bug in the compiler?)")
-              JSGlobalRef("Object")
-          }
+        case Some(Some(loadSpec)) =>
+          genLoadFromLoadSpec(loadSpec)
+        case Some(None) =>
+          reportError(
+              s"${className.nameString} does not have a load spec " +
+              "(this shouldn't have happened at all; bug in the compiler?)")
+          JSGlobalRef("Object")
         case None =>
           reportError(s"${className.nameString} is not a JS type")
           JSGlobalRef("Object")