Improving Command-Parsing in OPAL with Scallop-Library

.scalafmt.conf

@@ -15,15 +15,10 @@ indent {
 }
 indentOperator.exemptScope = aloneEnclosed
 
-project.excludePaths = [
-  "glob:**/DEVELOPING_OPAL/demos/src/main/scala/org/opalj/fpcf/analyses/InterProceduralEscapeAnalysisDemo.scala",
-  "glob:**/DEVELOPING_OPAL/demos/src/main/scala/org/opalj/fpcf/analyses/SimpleEscapeAnalysisDemo.scala"
-]
-
 newlines {
   source = keep
   afterCurlyLambdaParams = squash
-  avoidForSimpleOverflow = [slc, tooLong, punct] # singe line comment, does not add newline if line would be too long after,  punctuation
+  avoidForSimpleOverflow = [slc, tooLong, punct] # single line comment, does not add newline if line would be too long after punctuation
   topLevelStatementBlankLines = [{ blanks { before = 1 }, maxNest = 0 }]
   sometimesBeforeColonInMethodReturnType = false
   ignoreInSyntax = false
@@ -66,6 +61,7 @@ rewrite {
         "org\\.scalatest\\..*",
         "org\\.scalatestplus\\..*"],
       ["com\\.typesafe\\.config\\..*"],
+      ["org\\.rogach\\.scallop\\..*"],
       ["org\\.opalj\\..*"],
       ["scala\\.collection\\.parallel\\.CollectionConverters\\..*"]
       // Catch all

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/CipherGetInstanceStringUsage.scala → DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/CipherGetInstanceStrings.scala

@@ -2,6 +2,7 @@
 package org.opalj
 package ai
 
+import java.io.File
 import java.net.URL
 import java.util.concurrent.ConcurrentLinkedQueue
 import scala.jdk.CollectionConverters._
@@ -12,7 +13,8 @@ import org.opalj.br.MethodDescriptor.JustReturnsString
 import org.opalj.br.PCAndInstruction
 import org.opalj.br.analyses.BasicReport
 import org.opalj.br.analyses.Project
-import org.opalj.br.analyses.ProjectAnalysisApplication
+import org.opalj.br.analyses.ProjectsAnalysisApplication
+import org.opalj.br.fpcf.cli.MultiProjectAnalysisConfig
 import org.opalj.br.instructions.GETFIELD
 import org.opalj.br.instructions.INVOKEINTERFACE
 import org.opalj.br.instructions.INVOKESTATIC
@@ -28,11 +30,15 @@ import org.opalj.br.instructions.LoadString
  *
  * @author Michael Reif
  */
-object CipherGetInstanceStringUsage extends ProjectAnalysisApplication {
+object CipherGetInstanceStrings extends ProjectsAnalysisApplication {
 
-    override def title: String = "input value analysis for Chipher.getInstance calls"
+    protected class CipherInstanceConfig(args: Array[String]) extends MultiProjectAnalysisConfig(args) {
+        val description = "Collects parameter values of Cipher.getInstance calls"
+    }
+
+    protected type ConfigType = CipherInstanceConfig
 
-    override def description: String = "Analyzes the input values of Chipher.getInstance calls."
+    protected def createConfig(args: Array[String]): CipherInstanceConfig = new CipherInstanceConfig(args)
 
     // #################### CONSTANTS ####################
 
@@ -42,11 +48,12 @@ object CipherGetInstanceStringUsage extends ProjectAnalysisApplication {
 
     // #################### ANALYSIS ####################
 
-    override def doAnalyze(
-        project:       Project[URL],
-        parameters:    Seq[String],
-        isInterrupted: () => Boolean
-    ): BasicReport = {
+    override protected def analyze(
+        cp:             Iterable[File],
+        analysisConfig: CipherInstanceConfig,
+        execution:      Int
+    ): (Project[URL], BasicReport) = {
+        val (project, _) = analysisConfig.setupProject(cp)
 
         val report = new ConcurrentLinkedQueue[String]
 
@@ -71,6 +78,6 @@ object CipherGetInstanceStringUsage extends ProjectAnalysisApplication {
             }
         }
 
-        BasicReport(report.asScala.mkString("\n"))
+        (project, BasicReport(report.asScala.mkString("\n")))
     }
 }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/UselessComputationsMinimal.scala → DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/ConstantIfs.scala

@@ -2,25 +2,35 @@
 package org.opalj
 package ai
 
+import java.io.File
 import java.net.URL
 import java.util.concurrent.ConcurrentLinkedQueue
 import scala.jdk.CollectionConverters._
 
 import org.opalj.br.Method
 import org.opalj.br.analyses.BasicReport
 import org.opalj.br.analyses.Project
-import org.opalj.br.analyses.ProjectAnalysisApplication
+import org.opalj.br.analyses.ProjectsAnalysisApplication
+import org.opalj.br.analyses.SomeProject
+import org.opalj.br.fpcf.cli.MultiProjectAnalysisConfig
 import org.opalj.br.instructions.IFICMPInstruction
 
 /**
- * A shallow analysis that tries to identify useless computations; here, "ifs" where the condition
- * is constant.
+ * A shallow analysis that tries to identify useless computations; here, "ifs" where the condition is constant.
  *
  * @author Michael Eichberg
  */
-object UselessComputationsMinimal extends ProjectAnalysisApplication {
+object ConstantIfs extends ProjectsAnalysisApplication {
 
-    class AnalysisDomain(val project: Project[URL], val method: Method)
+    protected class ConstantIfsConfig(args: Array[String]) extends MultiProjectAnalysisConfig(args) {
+        val description = "Collects ifs where the condition is constant"
+    }
+
+    protected type ConfigType = ConstantIfsConfig
+
+    protected def createConfig(args: Array[String]): ConstantIfsConfig = new ConstantIfsConfig(args)
+
+    class AnalysisDomain(val project: SomeProject, val method: Method)
         extends CorrelationalDomain
         with domain.DefaultSpecialDomainValuesBinding
         with domain.DefaultHandlingOfMethodResults
@@ -39,16 +49,17 @@ object UselessComputationsMinimal extends ProjectAnalysisApplication {
         with domain.TheProject
         with domain.TheMethod
 
-    def doAnalyze(
-        theProject:    Project[URL],
-        parameters:    Seq[String],
-        isInterrupted: () => Boolean
-    ): BasicReport = {
+    override protected def analyze(
+        cp:             Iterable[File],
+        analysisConfig: ConstantIfsConfig,
+        execution:      Int
+    ): (Project[URL], BasicReport) = {
+        val (project, _) = analysisConfig.setupProject(cp)
 
         val results = new ConcurrentLinkedQueue[String]()
-        theProject.parForeachMethodWithBody(isInterrupted) { m =>
+        project.parForeachMethodWithBody() { m =>
             val method = m.method
-            val result = BaseAI(method, new AnalysisDomain(theProject, method))
+            val result = BaseAI(method, new AnalysisDomain(project, method))
             import result.domain.ConcreteIntegerValue
             collectPCWithOperands(result.domain)(method.body.get, result.operandsArray) {
                 case (
@@ -62,6 +73,6 @@ object UselessComputationsMinimal extends ProjectAnalysisApplication {
             }
         }
 
-        BasicReport(results.asScala.mkString(s"${results.size} useless computations:\n", "\n", "\n"))
+        (project, BasicReport(results.asScala.mkString(s"${results.size} useless computations:\n", "\n", "\n")))
     }
 }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/ExceptionUsage.scala

@@ -2,11 +2,25 @@
 package org.opalj
 package ai
 
+import java.io.File
 import java.net.URL
 
-import org.opalj.br._
-import org.opalj.br.analyses._
-import org.opalj.br.instructions._
+import org.opalj.br.ClassHierarchy
+import org.opalj.br.ClassType
+import org.opalj.br.Method
+import org.opalj.br.MethodWithBody
+import org.opalj.br.PC
+import org.opalj.br.analyses.BasicReport
+import org.opalj.br.analyses.Project
+import org.opalj.br.analyses.ProjectsAnalysisApplication
+import org.opalj.br.analyses.SomeProject
+import org.opalj.br.fpcf.cli.MultiProjectAnalysisConfig
+import org.opalj.br.instructions.AASTORE
+import org.opalj.br.instructions.ARETURN
+import org.opalj.br.instructions.ATHROW
+import org.opalj.br.instructions.FieldWriteAccess
+import org.opalj.br.instructions.MethodInvocationInstruction
+import org.opalj.log.OPALLogger
 
 import scala.collection.parallel.CollectionConverters.ImmutableIterableIsParallelizable
 
@@ -15,32 +29,36 @@ import scala.collection.parallel.CollectionConverters.ImmutableIterableIsParalle
  *
  * @author Michael Eichberg
  */
-object ExceptionUsage extends ProjectAnalysisApplication {
+object ExceptionUsage extends ProjectsAnalysisApplication {
 
-    override def title: String = "Intra-procedural Usage of Exceptions"
+    protected class ExceptionUsageConfig(args: Array[String]) extends MultiProjectAnalysisConfig(args) {
+        val description = "Collects intra-procedural usage of exceptions"
+    }
+
+    protected type ConfigType = ExceptionUsageConfig
 
-    override def description: String = "Analyses the usage of exceptions."
+    protected def createConfig(args: Array[String]): ExceptionUsageConfig = new ExceptionUsageConfig(args)
 
-    override def doAnalyze(
-        theProject:    Project[URL],
-        parameters:    Seq[String],
-        isInterrupted: () => Boolean
-    ): BasicReport = {
+    override protected def analyze(
+        cp:             Iterable[File],
+        analysisConfig: ExceptionUsageConfig,
+        execution:      Int
+    ): (Project[URL], BasicReport) = {
+        val (project, _) = analysisConfig.setupProject(cp)
 
-        implicit val ch: ClassHierarchy = theProject.classHierarchy
+        implicit val ch: ClassHierarchy = project.classHierarchy
 
-        if (theProject.classFile(ClassType("java/lang/Object")).isEmpty) {
-            Console.err.println(
-                "[warn] It seems as if the JDK was not loaded" +
-                    "(use: -libcp=<PATH TO THE JRE>); " +
-                    "the results of the analysis might not be useful."
-            )
+        if (project.classFile(ClassType("java/lang/Object")).isEmpty) {
+            OPALLogger.error(
+                "analysis configuration",
+                "It seems as if the JDK was not loaded; the results of the analysis might not be useful."
+            )(project.logContext)
         }
 
         val usages = (for {
-            classFile <- theProject.allProjectClassFiles.par
+            classFile <- project.allProjectClassFiles.par
             method @ MethodWithBody(body) <- classFile.methods
-            result = BaseAI(method, new ExceptionUsageAnalysisDomain(theProject, method))
+            result = BaseAI(method, new ExceptionUsageAnalysisDomain(project, method))
         } yield {
             import scala.collection.mutable._
 
@@ -133,13 +151,13 @@ object ExceptionUsage extends ProjectAnalysisApplication {
             else {
                 Some(usages)
             }
-        }).filter(_.isDefined).map(_.get).flatten
+        }).filter(_.isDefined).flatMap(_.get)
 
         val (notUsed, used) = usages.toSeq.partition(_.usageInformation.isEmpty)
         var report = used.map(_.toString).toList.sorted.mkString("\nUsed\n", "\n", "\n")
         report += notUsed.map(_.toString).toList.sorted.mkString("\nNot Used\n", "\n", "\n")
 
-        BasicReport(report)
+        (project, BasicReport(report))
     }
 
 }
@@ -171,7 +189,7 @@ object UsageKind extends Enumeration {
     val StoredInField = UsageKind.Value
 }
 
-class ExceptionUsageAnalysisDomain(val project: Project[java.net.URL], val method: Method)
+class ExceptionUsageAnalysisDomain(val project: SomeProject, val method: Method)
     extends CorrelationalDomain
     with domain.DefaultSpecialDomainValuesBinding
     with domain.l0.TypeLevelPrimitiveValuesConversions

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/InfiniteRecursions.scala

@@ -4,6 +4,7 @@ package ai
 
 import scala.language.existentials
 
+import java.io.File
 import java.net.URL
 import scala.Console.BLUE
 import scala.Console.BOLD
@@ -12,8 +13,9 @@ import scala.Console.RESET
 import org.opalj.br.Method
 import org.opalj.br.analyses.BasicReport
 import org.opalj.br.analyses.Project
-import org.opalj.br.analyses.ProjectAnalysisApplication
+import org.opalj.br.analyses.ProjectsAnalysisApplication
 import org.opalj.br.analyses.SomeProject
+import org.opalj.br.fpcf.cli.MultiProjectAnalysisConfig
 import org.opalj.br.instructions.INVOKEINTERFACE
 import org.opalj.br.instructions.INVOKESPECIAL
 import org.opalj.br.instructions.INVOKESTATIC
@@ -28,19 +30,22 @@ import scala.collection.parallel.CollectionConverters.IterableIsParallelizable
  * @author Marco Jacobasch
  * @author Michael Eichberg
  */
-object InfiniteRecursions extends ProjectAnalysisApplication {
+object InfiniteRecursions extends ProjectsAnalysisApplication {
 
-    override def title: String = "infinite recursions analysis"
-
-    override def description: String = {
-        "identifies method which calls themselves using infinite recursion"
+    protected class InfiniteRecursionConfig(args: Array[String]) extends MultiProjectAnalysisConfig(args) {
+        val description = "Identifies method which calls themselves using infinite recursion"
     }
 
-    override def doAnalyze(
-        project:       Project[URL],
-        parameters:    Seq[String] = List.empty,
-        isInterrupted: () => Boolean
-    ): BasicReport = {
+    protected type ConfigType = InfiniteRecursionConfig
+
+    protected def createConfig(args: Array[String]): InfiniteRecursionConfig = new InfiniteRecursionConfig(args)
+
+    override protected def analyze(
+        cp:             Iterable[File],
+        analysisConfig: InfiniteRecursionConfig,
+        execution:      Int
+    ): (Project[URL], BasicReport) = {
+        val (project, _) = analysisConfig.setupProject(cp)
 
         // In a real application we should take this from a parameter
         val maxRecursionDepth = 3
@@ -72,7 +77,7 @@ object InfiniteRecursions extends ProjectAnalysisApplication {
                 result <- inifiniteRecursions(maxRecursionDepth, project, method, pcs)
             } yield { result }
 
-        BasicReport(result.map(_.toString).mkString("\n"))
+        (project, BasicReport(result.map(_.toString).mkString("\n")))
     }
 
     /**