analyzing everything before writing

Author: nikololiahim

.gitignore

@@ -11,3 +11,4 @@ j2eo.jar
 sarif/**
 polystat-x86_64-pc-linux
 out/
+**.json

build.sbt

@@ -31,7 +31,7 @@ buildInfoPackage := "org.polystat.cli"
 
 Global / excludeLintKeys += nativeImageVersion
 
-Compile / mainClass := Some("org.polystat.Main")
+Compile / mainClass := Some("org.polystat.cli.Main")
 
 enablePlugins(NativeImagePlugin)
 nativeImageVersion := "22.1.0"

src/main/scala/org/polystat/cli/EO.scala

@@ -9,9 +9,11 @@ import org.polystat.odin.analysis.EOOdinAnalyzer
 import org.polystat.odin.parser.EoParser.sourceCodeEoParser
 import org.polystat.sarif.AggregatedSarifOutput
 import org.polystat.sarif.SarifOutput
+import fs2.io.file.Path
 
 import PolystatConfig.*
 import InputUtils.*
+import org.polystat.odin.analysis.EOOdinAnalyzer.OdinAnalysisResult
 
 object EO:
 
@@ -27,60 +29,60 @@ object EO:
     val inputFiles = readCodeFromInput(".eo", cfg.input)
     val analyzed = inputFiles
       .evalMap { case (codePath, code) =>
-        for analyzed <- runAnalyzers(cfg.filteredAnalyzers)(code)
+        for
+          _ <- IO.println(s"Analyzing $codePath...")
+          analyzed <- runAnalyzers(cfg.filteredAnalyzers)(code)
         yield (codePath, analyzed)
       }
       .compile
       .toVector
-      .map(_.toMap)
-    val analyzeToDirs = inputFiles
-      .evalMap { case (codePath, code) =>
+
+    def writeToDirs(analyzed: Vector[(Path, List[OdinAnalysisResult])]) =
+      analyzed.traverse_ { case (codePath, results) =>
         for
-          _ <- IO.println(s"Analyzing $codePath...")
-          analyzed <- runAnalyzers(cfg.filteredAnalyzers)(code)
           _ <- if cfg.output.console then IO.println(analyzed) else IO.unit
           _ <- cfg.fmts.traverse_ { case OutputFormat.Sarif =>
             val sarifJson = SarifOutput(
               codePath,
-              analyzed,
+              results,
             ).json.toString
             cfg.output.dirs.traverse_(out =>
               val outPath =
                 out / "sarif" / codePath.replaceExt(".sarif.json")
               for
-                _ <- IO.println(s"Writing results to $outPath")
+                _ <- IO.println(s"Writing results to $outPath...")
                 _ <- writeOutputTo(outPath)(sarifJson)
               yield ()
             )
           }
         yield ()
       }
-      .compile
-      .drain
-    val analyzeAggregate = cfg.output.files.traverse_ { outputPath =>
-      cfg.fmts.traverse_ { case OutputFormat.Sarif =>
-        for
-          _ <- IO.println(s"Writing aggregated output to $outputPath...")
-          analyzed <- analyzed
-          sariOutput = AggregatedSarifOutput
-            .fromAnalyzed(analyzed)
-            .asJson
-            .deepDropNullValues
-            .toString
-          _ <- writeOutputTo(outputPath)(sariOutput)
-        yield ()
+
+    def writeAggregate(analyzed: Vector[(Path, List[OdinAnalysisResult])]) =
+      cfg.output.files.traverse_ { outputPath =>
+        cfg.fmts.traverse_ { case OutputFormat.Sarif =>
+          for
+            _ <- IO.println(s"Writing aggregated output to $outputPath...")
+            sariOutput = AggregatedSarifOutput
+              .fromAnalyzed(analyzed)
+              .asJson
+              .deepDropNullValues
+              .toString
+            _ <- writeOutputTo(outputPath)(sariOutput)
+          yield ()
+        }
       }
-    }
 
     for
+      analyzed <- analyzed
       _ <- cfg.output.dirs.traverse_ { outDir =>
         for
           _ <- IO.println(s"Cleaning $outDir before writing...")
           _ <- outDir.clean
         yield ()
       }
-      _ <- analyzeToDirs
-      _ <- analyzeAggregate
+      _ <- writeToDirs(analyzed)
+      _ <- writeAggregate(analyzed)
     yield ()
     end for
   end analyze

src/main/scala/org/polystat/sarif/AggregatedSarifOutput.scala

@@ -5,11 +5,15 @@ import org.polystat.odin.analysis.EOOdinAnalyzer.OdinAnalysisResult
 
 import Sarif.*
 
+case class AggregatedSarifOutput(
+    analyzed: Seq[(Path, List[OdinAnalysisResult])]
+)
+
 object AggregatedSarifOutput:
   def fromAnalyzed(
-      analyzed: Map[Path, List[OdinAnalysisResult]]
+      analyzed: Seq[(Path, List[OdinAnalysisResult])]
   ): Seq[SarifLog] =
-    analyzed.toSeq.map { case (path, results) =>
+    analyzed.map { case (path, results) =>
       SarifOutput(path, results).sarif
     }
 end AggregatedSarifOutput