Extract IFDSProblem(flow functions etc) from IFDSAnalysis

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/heros/analyses/HerosAnalysis.scala

@@ -22,7 +22,7 @@ import org.opalj.tac.fpcf.properties.cg.Callers
 import org.opalj.ai.domain.l2
 import org.opalj.ai.fpcf.properties.AIDomainFactoryKey
 import org.opalj.tac.fpcf.analyses.heros.cfg.OpalICFG
-import org.opalj.tac.fpcf.analyses.ifds.Statement
+import org.opalj.tac.fpcf.analyses.ifds.JavaStatement
 import org.opalj.tac.Assignment
 import org.opalj.tac.Call
 import org.opalj.tac.ExprStmt
@@ -40,7 +40,7 @@ import org.opalj.tac.fpcf.analyses.ifds.AbstractIFDSAnalysis.V
  * @author Mario Trageser
  */
 abstract class HerosAnalysis[F](p: SomeProject, icfg: OpalICFG)
-    extends DefaultIFDSTabulationProblem[Statement, F, Method, OpalICFG](icfg) {
+    extends DefaultIFDSTabulationProblem[JavaStatement, F, Method, OpalICFG](icfg) {
 
     /**
      * The project's property store.

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/heros/analyses/HerosVariableTypeAnalysis.scala

@@ -30,7 +30,7 @@ import org.opalj.br.analyses.DeclaredMethodsKey
 import org.opalj.br.fpcf.PropertyStoreKey
 import org.opalj.br.DeclaredMethod
 import org.opalj.tac.fpcf.properties.cg.Callees
-import org.opalj.tac.fpcf.analyses.ifds.Statement
+import org.opalj.tac.fpcf.analyses.ifds.JavaStatement
 import org.opalj.tac.Assignment
 import org.opalj.tac.Expr
 import org.opalj.tac.GetStatic
@@ -59,8 +59,8 @@ class HerosVariableTypeAnalysis(
         initialMethods: Map[Method, util.Set[VTAFact]]
 ) extends HerosAnalysis[VTAFact](p, icfg) {
 
-    override val initialSeeds: util.Map[Statement, util.Set[VTAFact]] = {
-        var result: Map[Statement, util.Set[VTAFact]] = Map.empty
+    override val initialSeeds: util.Map[JavaStatement, util.Set[VTAFact]] = {
+        var result: Map[JavaStatement, util.Set[VTAFact]] = Map.empty
         for ((m, facts) ← initialMethods) {
             result += icfg.getStartPointsOf(m).iterator().next() -> facts
         }
@@ -69,13 +69,13 @@ class HerosVariableTypeAnalysis(
 
     override def createZeroValue(): VTAFact = VTANullFact
 
-    override protected def createFlowFunctionsFactory(): FlowFunctions[Statement, VTAFact, Method] = {
+    override protected def createFlowFunctionsFactory(): FlowFunctions[JavaStatement, VTAFact, Method] = {
 
-        new FlowFunctions[Statement, VTAFact, Method]() {
+        new FlowFunctions[JavaStatement, VTAFact, Method]() {
 
             override def getNormalFlowFunction(
-                statement: Statement,
-                succ:      Statement
+                statement: JavaStatement,
+                succ:      JavaStatement
             ): FlowFunction[VTAFact] = {
                 if (!insideAnalysisContext(statement.method)) return KillAll.v()
                 val stmt = statement.stmt
@@ -103,7 +103,7 @@ class HerosVariableTypeAnalysis(
                 }
             }
 
-            override def getCallFlowFunction(stmt: Statement, callee: Method): FlowFunction[VTAFact] =
+            override def getCallFlowFunction(stmt: JavaStatement, callee: Method): FlowFunction[VTAFact] =
                 if (!insideAnalysisContext(callee)) KillAll.v()
                 else {
                     val callObject = asCall(stmt.stmt)
@@ -129,10 +129,10 @@ class HerosVariableTypeAnalysis(
                 }
 
             override def getReturnFlowFunction(
-                stmt:   Statement,
+                stmt:   JavaStatement,
                 callee: Method,
-                exit:   Statement,
-                succ:   Statement
+                exit:   JavaStatement,
+                succ:   JavaStatement
             ): FlowFunction[VTAFact] =
                 if (exit.stmt.astID == ReturnValue.ASTID && stmt.stmt.astID == Assignment.ASTID) {
                     val returnValue = exit.stmt.asReturnValue.expr.asVar
@@ -147,8 +147,8 @@ class HerosVariableTypeAnalysis(
                 } else KillAll.v()
 
             override def getCallToReturnFlowFunction(
-                statement: Statement,
-                succ:      Statement
+                statement: JavaStatement,
+                succ:      JavaStatement
             ): FlowFunction[VTAFact] = {
                 if (!insideAnalysisContext(statement.method)) return KillAll.v()
                 val stmt = statement.stmt
@@ -227,7 +227,7 @@ class HerosVariableTypeAnalysis(
         callee.body.isDefined && (callee.classFile.fqn.startsWith("java/lang") ||
             callee.classFile.fqn.startsWith("org/opalj/fpcf/fixtures/vta"))
 
-    private def getCallees(statement: Statement): Iterator[DeclaredMethod] = {
+    private def getCallees(statement: JavaStatement): Iterator[DeclaredMethod] = {
         val context = typeProvider.newContext(declaredMethods(statement.method))
         val FinalEP(_, callees) = propertyStore(declaredMethods(statement.method), Callees.key)
         callees.directCallees(context, statement.stmt.pc).map(_.method)

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/heros/analyses/VTAEquality.scala

@@ -31,7 +31,7 @@ import org.opalj.tac.cg.RTACallGraphKey
 import org.opalj.tac.fpcf.analyses.heros.cfg.OpalForwardICFG
 import org.opalj.tac.fpcf.analyses.ifds.CalleeType
 import org.opalj.tac.fpcf.analyses.ifds.IFDSBasedVariableTypeAnalysis
-import org.opalj.tac.fpcf.analyses.ifds.Statement
+import org.opalj.tac.fpcf.analyses.ifds.JavaStatement
 import org.opalj.tac.fpcf.analyses.ifds.VariableType
 import org.opalj.tac.fpcf.analyses.ifds.VTAFact
 import org.opalj.tac.fpcf.analyses.ifds.VTANullFact
@@ -115,7 +115,7 @@ object VTAEquality {
             piKeyUnidueId != PropertyStoreKey.uniqueId
         }
         val propertyStore = project.get(PropertyStoreKey)
-        var result = Map.empty[Statement, Set[VTAFact]]
+        var result = Map.empty[JavaStatement, Set[VTAFact]]
         project.updateProjectInformationKeyInitializationData(AIDomainFactoryKey) {
             case None ⇒ Set(classOf[l2.DefaultPerformInvocationsDomainWithCFGAndDefUse[_]])
             case Some(requirements) ⇒

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/heros/analyses/taint/HerosBackwardClassForNameAnalysis.scala

@@ -16,7 +16,7 @@ import org.opalj.br.Method
 import org.opalj.br.ObjectType
 import org.opalj.tac.fpcf.analyses.heros.cfg.OpalBackwardICFG
 import org.opalj.tac.fpcf.analyses.ifds.taint.Fact
-import org.opalj.tac.fpcf.analyses.ifds.Statement
+import org.opalj.tac.fpcf.analyses.ifds.JavaStatement
 import org.opalj.tac.Assignment
 import org.opalj.tac.fpcf.analyses.ifds.taint.ArrayElement
 import org.opalj.tac.fpcf.analyses.ifds.taint.Variable
@@ -40,7 +40,7 @@ import org.opalj.tac.ReturnValue
 import org.opalj.tac.fpcf.analyses.heros.analyses.HerosAnalysis
 import org.opalj.tac.fpcf.analyses.heros.analyses.HerosAnalysisRunner
 import org.opalj.tac.fpcf.analyses.ifds.taint.FlowFact
-import org.opalj.tac.fpcf.analyses.ifds.taint.TaintAnalysis
+import org.opalj.tac.fpcf.analyses.ifds.taint.TaintProblem
 import org.opalj.tac.fpcf.analyses.ifds.AbstractIFDSAnalysis
 
 /**
@@ -51,7 +51,7 @@ import org.opalj.tac.fpcf.analyses.ifds.AbstractIFDSAnalysis
  */
 class HerosBackwardClassForNameAnalysis(p: SomeProject, icfg: OpalBackwardICFG) extends HerosTaintAnalysis(p, icfg) {
 
-    override val initialSeeds: util.Map[Statement, util.Set[Fact]] =
+    override val initialSeeds: util.Map[JavaStatement, util.Set[Fact]] =
         p.allProjectClassFiles.filter(classFile ⇒
             classFile.thisType.fqn == "java/lang/Class")
             .flatMap(classFile ⇒ classFile.methods)
@@ -62,11 +62,11 @@ class HerosBackwardClassForNameAnalysis(p: SomeProject, icfg: OpalBackwardICFG)
 
     override def followReturnsPastSeeds(): Boolean = true
 
-    override def createFlowFunctionsFactory(): FlowFunctions[Statement, Fact, Method] = {
+    override def createFlowFunctionsFactory(): FlowFunctions[JavaStatement, Fact, Method] = {
 
-        new FlowFunctions[Statement, Fact, Method]() {
+        new FlowFunctions[JavaStatement, Fact, Method]() {
 
-            override def getNormalFlowFunction(statement: Statement, succ: Statement): FlowFunction[Fact] = {
+            override def getNormalFlowFunction(statement: JavaStatement, succ: JavaStatement): FlowFunction[Fact] = {
                 val method = statement.method
                 val stmt = statement.stmt
                 source: Fact ⇒ {
@@ -77,7 +77,7 @@ class HerosBackwardClassForNameAnalysis(p: SomeProject, icfg: OpalBackwardICFG)
                             else Set(source)
                         case ArrayStore.ASTID ⇒
                             val arrayStore = stmt.asArrayStore
-                            val arrayIndex = TaintAnalysis.getIntConstant(arrayStore.index, statement.code)
+                            val arrayIndex = TaintProblem.getIntConstant(arrayStore.index, statement.code)
                             val arrayDefinedBy = arrayStore.arrayRef.asVar.definedBy
                             var facts = (source match {
                                 // In this case, we taint the whole array.
@@ -127,7 +127,7 @@ class HerosBackwardClassForNameAnalysis(p: SomeProject, icfg: OpalBackwardICFG)
 
             }
 
-            override def getCallFlowFunction(stmt: Statement, callee: Method): FlowFunction[Fact] = {
+            override def getCallFlowFunction(stmt: JavaStatement, callee: Method): FlowFunction[Fact] = {
                 val callObject = asCall(stmt.stmt)
                 val staticCall = callee.isStatic
                 source: Fact ⇒ {
@@ -169,7 +169,7 @@ class HerosBackwardClassForNameAnalysis(p: SomeProject, icfg: OpalBackwardICFG)
                 }
             }
 
-            override def getReturnFlowFunction(statement: Statement, callee: Method, exit: Statement, succ: Statement): FlowFunction[Fact] = {
+            override def getReturnFlowFunction(statement: JavaStatement, callee: Method, exit: JavaStatement, succ: JavaStatement): FlowFunction[Fact] = {
                 // If a method has no caller, returnFlow will be called with a null statement.
                 if (statement == null) return Identity.v()
                 val stmt = statement.stmt
@@ -199,7 +199,7 @@ class HerosBackwardClassForNameAnalysis(p: SomeProject, icfg: OpalBackwardICFG)
                     }).asJava
             }
 
-            override def getCallToReturnFlowFunction(stmt: Statement, succ: Statement): FlowFunction[Fact] =
+            override def getCallToReturnFlowFunction(stmt: JavaStatement, succ: JavaStatement): FlowFunction[Fact] =
                 Identity.v()
         }
     }
@@ -221,12 +221,12 @@ class HerosBackwardClassForNameAnalysis(p: SomeProject, icfg: OpalBackwardICFG)
         }.toSet
     }
 
-    private def createNewTaints(expression: Expr[V], statement: Statement): Set[Fact] =
+    private def createNewTaints(expression: Expr[V], statement: JavaStatement): Set[Fact] =
         expression.astID match {
             case Var.ASTID ⇒ expression.asVar.definedBy.map(Variable)
             case ArrayLoad.ASTID ⇒
                 val arrayLoad = expression.asArrayLoad
-                val arrayIndex = TaintAnalysis.getIntConstant(expression.asArrayLoad.index, statement.code)
+                val arrayIndex = TaintProblem.getIntConstant(expression.asArrayLoad.index, statement.code)
                 val arrayDefinedBy = arrayLoad.arrayRef.asVar.definedBy
                 if (arrayIndex.isDefined) arrayDefinedBy.map(ArrayElement(_, arrayIndex.get))
                 else arrayDefinedBy.map(Variable)

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/heros/analyses/taint/HerosForwardClassForNameAnalysis.scala

@@ -33,7 +33,7 @@ import org.opalj.tac.PutField
 import org.opalj.tac.PutStatic
 import org.opalj.tac.ReturnValue
 import org.opalj.tac.Var
-import org.opalj.tac.fpcf.analyses.ifds.Statement
+import org.opalj.tac.fpcf.analyses.ifds.JavaStatement
 import org.opalj.tac.fpcf.analyses.ifds.taint.ArrayElement
 import org.opalj.tac.fpcf.analyses.ifds.taint.Fact
 import org.opalj.tac.fpcf.analyses.ifds.taint.FlowFact
@@ -50,7 +50,7 @@ import org.opalj.tac.PrefixExpr
 import org.opalj.tac.PrimitiveTypecastExpr
 import org.opalj.tac.fpcf.analyses.heros.analyses.HerosAnalysis
 import org.opalj.tac.fpcf.analyses.heros.analyses.HerosAnalysisRunner
-import org.opalj.tac.fpcf.analyses.ifds.taint.TaintAnalysis
+import org.opalj.tac.fpcf.analyses.ifds.taint.TaintProblem
 import org.opalj.tac.fpcf.analyses.ifds.AbstractIFDSAnalysis
 import org.opalj.tac.fpcf.analyses.ifds.AbstractIFDSAnalysis.V
 
@@ -66,8 +66,8 @@ class HerosForwardClassForNameAnalysis(
         initialMethods: Map[Method, util.Set[Fact]]
 ) extends HerosTaintAnalysis(p, icfg) {
 
-    override val initialSeeds: util.Map[Statement, util.Set[Fact]] = {
-        var result: Map[Statement, util.Set[Fact]] = Map.empty
+    override val initialSeeds: util.Map[JavaStatement, util.Set[Fact]] = {
+        var result: Map[JavaStatement, util.Set[Fact]] = Map.empty
         for ((m, facts) ← initialMethods) {
             result += icfg.getStartPointsOf(m).iterator().next() -> facts
         }
@@ -78,18 +78,18 @@ class HerosForwardClassForNameAnalysis(
 
     var flowFacts = Map.empty[Method, Set[FlowFact]]
 
-    override def createFlowFunctionsFactory(): FlowFunctions[Statement, Fact, Method] = {
+    override def createFlowFunctionsFactory(): FlowFunctions[JavaStatement, Fact, Method] = {
 
-        new FlowFunctions[Statement, Fact, Method]() {
+        new FlowFunctions[JavaStatement, Fact, Method]() {
 
-            override def getNormalFlowFunction(stmt: Statement, succ: Statement): FlowFunction[Fact] = {
+            override def getNormalFlowFunction(stmt: JavaStatement, succ: JavaStatement): FlowFunction[Fact] = {
                 stmt.stmt.astID match {
                     case Assignment.ASTID ⇒
                         handleAssignment(stmt, stmt.stmt.asAssignment.expr)
                     case ArrayStore.ASTID ⇒
                         val store = stmt.stmt.asArrayStore
                         val definedBy = store.arrayRef.asVar.definedBy
-                        val index = TaintAnalysis.getIntConstant(store.index, stmt.code)
+                        val index = TaintProblem.getIntConstant(store.index, stmt.code)
                         (source: Fact) ⇒ {
                             if (isTainted(store.value, source)) {
                                 if (index.isDefined) {
@@ -131,7 +131,7 @@ class HerosForwardClassForNameAnalysis(
                 }
             }
 
-            def handleAssignment(stmt: Statement, expr: Expr[V]): FlowFunction[Fact] =
+            def handleAssignment(stmt: JavaStatement, expr: Expr[V]): FlowFunction[Fact] =
                 expr.astID match {
                     case Var.ASTID ⇒
                         (source: Fact) ⇒ {
@@ -148,7 +148,7 @@ class HerosForwardClassForNameAnalysis(
                             source match {
                                 // The specific array element may be tainted
                                 case ArrayElement(index, taintedIndex) ⇒
-                                    val arrIndex = TaintAnalysis.getIntConstant(load.index, stmt.code)
+                                    val arrIndex = TaintProblem.getIntConstant(load.index, stmt.code)
                                     if (arrayDefinedBy.contains(index) &&
                                         (arrIndex.isEmpty || taintedIndex == arrIndex.get))
                                         TwoElementSet.twoElementSet(source, Variable(stmt.index))
@@ -198,7 +198,7 @@ class HerosForwardClassForNameAnalysis(
                     case _ ⇒ Identity.v()
                 }
 
-            override def getCallFlowFunction(stmt: Statement, callee: Method): FlowFunction[Fact] = {
+            override def getCallFlowFunction(stmt: JavaStatement, callee: Method): FlowFunction[Fact] = {
                 val callObject = asCall(stmt.stmt)
                 val allParams = callObject.allParams
                 if (relevantCallee(callee)) {
@@ -252,10 +252,10 @@ class HerosForwardClassForNameAnalysis(
             }
 
             override def getReturnFlowFunction(
-                stmt:   Statement,
+                stmt:   JavaStatement,
                 callee: Method,
-                exit:   Statement,
-                succ:   Statement
+                exit:   JavaStatement,
+                succ:   JavaStatement
             ): FlowFunction[Fact] = {
 
                 def isRefTypeParam(index: Int): Boolean =
@@ -348,8 +348,8 @@ class HerosForwardClassForNameAnalysis(
             }
 
             override def getCallToReturnFlowFunction(
-                stmt: Statement,
-                succ: Statement
+                stmt: JavaStatement,
+                succ: JavaStatement
             ): FlowFunction[Fact] =
                 Identity.v()
         }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/heros/cfg/OpalBackwardICFG.scala

@@ -12,7 +12,7 @@ import scala.collection.JavaConverters._
 import org.opalj.br.analyses.SomeProject
 import org.opalj.br.Method
 import org.opalj.br.cfg.BasicBlock
-import org.opalj.tac.fpcf.analyses.ifds.Statement
+import org.opalj.tac.fpcf.analyses.ifds.JavaStatement
 import org.opalj.tac.TACode
 
 /**
@@ -22,31 +22,31 @@ import org.opalj.tac.TACode
  */
 class OpalBackwardICFG(project: SomeProject) extends OpalICFG(project) {
 
-    override def getPredsOf(stmt: Statement): JList[Statement] = super.getSuccsOf(stmt)
+    override def getPredsOf(stmt: JavaStatement): JList[JavaStatement] = super.getSuccsOf(stmt)
 
-    override def getSuccsOf(stmt: Statement): JList[Statement] = super.getPredsOf(stmt)
+    override def getSuccsOf(stmt: JavaStatement): JList[JavaStatement] = super.getPredsOf(stmt)
 
-    override def getStartPointsOf(m: Method): JCollection[Statement] = {
+    override def getStartPointsOf(m: Method): JCollection[JavaStatement] = {
         val TACode(_, code, _, cfg, _) = tacai(m)
         (cfg.normalReturnNode.predecessors ++ cfg.abnormalReturnNode.predecessors).map {
             case bb: BasicBlock ⇒
                 val index = bb.endPC
-                Statement(m, bb, code(index), index, code, cfg)
+                JavaStatement(m, bb, code(index), index, code, cfg)
         }.asJava
     }
 
-    override def isExitStmt(stmt: Statement): Boolean = stmt.index == 0
+    override def isExitStmt(stmt: JavaStatement): Boolean = stmt.index == 0
 
-    override def isStartPoint(stmt: Statement): Boolean = {
+    override def isStartPoint(stmt: JavaStatement): Boolean = {
         val cfg = stmt.cfg
         val index = stmt.index
         (cfg.normalReturnNode.predecessors ++ cfg.abnormalReturnNode.predecessors).exists {
             case bb: BasicBlock ⇒ bb.endPC == index
         }
     }
 
-    override def allNonCallStartNodes(): JSet[Statement] = {
-        val res = new ConcurrentLinkedQueue[Statement]
+    override def allNonCallStartNodes(): JSet[JavaStatement] = {
+        val res = new ConcurrentLinkedQueue[JavaStatement]
         project.parForeachMethodWithBody() { mi ⇒
             val m = mi.method
             val TACode(_, code, _, cfg, _) = tacai(m)
@@ -58,7 +58,7 @@ class OpalBackwardICFG(project: SomeProject) extends OpalICFG(project) {
             var index = 0
             while (index < endIndex) {
                 val stmt = code(index)
-                val statement = Statement(m, cfg.bb(index), stmt, index, code, cfg)
+                val statement = JavaStatement(m, cfg.bb(index), stmt, index, code, cfg)
                 if (!(isCallStmt(statement) || startIndices.contains(index)))
                     res.add(statement)
                 index += 1
@@ -68,10 +68,10 @@ class OpalBackwardICFG(project: SomeProject) extends OpalICFG(project) {
         Collections.emptySet()
     }
 
-    def getExitStmt(method: Method): Statement = {
+    def getExitStmt(method: Method): JavaStatement = {
         val tac = tacai(method)
         val cfg = tac.cfg
         val code = tac.stmts
-        Statement(method, cfg.startBlock, code(0), 0, code, cfg)
+        JavaStatement(method, cfg.startBlock, code(0), 0, code, cfg)
     }
 }