Move logic for handling methods without body out of ReachableMethodAnalysis

Author: Dominik Helm

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/SystemPropertiesAnalysisScheduler.scala

@@ -26,13 +26,13 @@ import org.opalj.fpcf.PropertyStore
 import org.opalj.fpcf.Results
 import org.opalj.fpcf.UBP
 import org.opalj.tac.cg.TypeIteratorKey
-import org.opalj.tac.fpcf.analyses.cg.DefinedBodyReachableMethodAnalysis
+import org.opalj.tac.fpcf.analyses.cg.ReachableMethodAnalysis
 import org.opalj.tac.fpcf.properties.TACAI
 import org.opalj.value.ValueInformation
 
 class SystemPropertiesAnalysisScheduler private[analyses] (
     final val project: SomeProject
-) extends DefinedBodyReachableMethodAnalysis {
+) extends ReachableMethodAnalysis {
 
     def processMethod(
         callContext: ContextType,

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/cg/CallGraphAnalysis.scala

@@ -5,6 +5,7 @@ package fpcf
 package analyses
 package cg
 
+import org.opalj.br.DeclaredMethod
 import org.opalj.br.Method
 import org.opalj.br.MethodDescriptor
 import org.opalj.br.ObjectType
@@ -28,6 +29,7 @@ import org.opalj.fpcf.InterimPartialResult
 import org.opalj.fpcf.InterimUBP
 import org.opalj.fpcf.ProperPropertyComputationResult
 import org.opalj.fpcf.PropertyBounds
+import org.opalj.fpcf.PropertyComputationResult
 import org.opalj.fpcf.PropertyKind
 import org.opalj.fpcf.PropertyStore
 import org.opalj.fpcf.Results
@@ -119,12 +121,16 @@ class CallGraphAnalysis private[cg] (
         }
     }
 
+    override final def processMethodWithoutBody(eOptP: EOptionP[DeclaredMethod, Callers]): PropertyComputationResult = {
+        processMethodWithoutBody(eOptP, null)
+    }
+
     override final def processMethod(
         callContext: ContextType,
-        tacEPOpt:    EOptionP[Method, TACAI]
+        tacEP:       EPS[Method, TACAI]
     ): ProperPropertyComputationResult = {
-        if (tacEPOpt.hasUBP) {
-            val state = new TACAIBasedCGState[ContextType](callContext, tacEPOpt)
+        if (tacEP ne null) {
+            val state = new TACAIBasedCGState[ContextType](callContext, tacEP)
             processMethod(state, new DirectCalls())
         } else {
             Results(new DirectCalls().partialResults(callContext, enforceCalleesResult = true))

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/cg/ReachableMethodAnalysis.scala

@@ -13,7 +13,6 @@ import org.opalj.br.fpcf.FPCFAnalysis
 import org.opalj.br.fpcf.properties.cg.Callers
 import org.opalj.br.fpcf.properties.cg.NoCallers
 import org.opalj.fpcf.EOptionP
-import org.opalj.fpcf.EPK
 import org.opalj.fpcf.EPS
 import org.opalj.fpcf.InterimPartialResult
 import org.opalj.fpcf.NoResult
@@ -28,6 +27,8 @@ import org.opalj.tac.fpcf.properties.TACAI
  * Base trait for analyses that are executed for every method that is reachable.
  * The analysis is performed by `processMethod`.
  *
+ * Note that methods without a body are not processed unless `processMethodWithoutBody` is overridden
+ *
  * @author Florian Kuebler
  */
 trait ReachableMethodAnalysis extends FPCFAnalysis with TypeConsumerAnalysis {
@@ -57,20 +58,27 @@ trait ReachableMethodAnalysis extends FPCFAnalysis with TypeConsumerAnalysis {
 
         val tacEP = propertyStore(method, TACAI.key)
         if (tacEP.hasUBP && tacEP.ub.tac.isDefined) {
-            processMethod(callersEOptP, NoCallers, tacEP)
+            processMethod(callersEOptP, NoCallers, tacEP.asEPS)
         } else {
             InterimPartialResult(Set(tacEP), continuationForTAC(declaredMethod))
         }
     }
 
     protected def processMethodWithoutBody(
         eOptP: EOptionP[DeclaredMethod, Callers]
-    ): PropertyComputationResult = processMethod(eOptP, NoCallers, EPK(eOptP.e.definedMethod, TACAI.key))
+    ): PropertyComputationResult = NoResult
+
+    protected def processMethodWithoutBody(
+        eOptP:      EOptionP[DeclaredMethod, Callers],
+        tacEP:      EPS[Method, TACAI]
+    ): ProperPropertyComputationResult = {
+        processMethod(eOptP, NoCallers, tacEP)
+    }
 
-    private[this] def processMethod(
+    protected def processMethod(
         eOptP:      EOptionP[DeclaredMethod, Callers],
         oldCallers: Callers,
-        tacEOptP:   EOptionP[Method, TACAI]
+        tacEP:      EPS[Method, TACAI]
     ): ProperPropertyComputationResult = {
         val newCallers = if (eOptP.hasUBP) eOptP.ub else NoCallers
         var results: List[ProperPropertyComputationResult] = Nil
@@ -79,18 +87,18 @@ trait ReachableMethodAnalysis extends FPCFAnalysis with TypeConsumerAnalysis {
             val theCalleeContext =
                 if (calleeContext.hasContext) calleeContext.asInstanceOf[ContextType]
                 else typeIterator.newContext(eOptP.e)
-            results ::= processMethod(theCalleeContext, tacEOptP)
+            results ::= processMethod(theCalleeContext, tacEP)
         }
 
         Results(
-            InterimPartialResult(Set(eOptP), continuationForCallers(newCallers, tacEOptP)),
+            InterimPartialResult(Set(eOptP), continuationForCallers(newCallers, tacEP)),
             results
         )
     }
 
     def processMethod(
         callContext: ContextType,
-        tacEOptP:    EOptionP[Method, TACAI]
+        tacEP:       EPS[Method, TACAI]
     ): ProperPropertyComputationResult
 
     protected def continuationForTAC(
@@ -110,28 +118,11 @@ trait ReachableMethodAnalysis extends FPCFAnalysis with TypeConsumerAnalysis {
 
     private[this] def continuationForCallers(
         oldCallers: Callers,
-        tacEOptP:   EOptionP[Method, TACAI]
+        tacEP:      EPS[Method, TACAI]
     )(
         update: SomeEPS
     ): ProperPropertyComputationResult = {
         val newCallers = update.asInstanceOf[EPS[DeclaredMethod, Callers]]
-        processMethod(newCallers, oldCallers, tacEOptP)
+        processMethod(newCallers, oldCallers, tacEP)
     }
 }
-
-trait DefinedBodyReachableMethodAnalysis extends ReachableMethodAnalysis {
-
-    override protected final def processMethodWithoutBody(
-        eOptP: EOptionP[DeclaredMethod, Callers]
-    ): PropertyComputationResult = NoResult
-
-    override final def processMethod(
-        callContext: ContextType,
-        tacEPOpt:    EOptionP[Method, TACAI]
-    ): ProperPropertyComputationResult = processMethod(callContext, tacEPOpt.asEPS)
-
-    def processMethod(
-        callContext: ContextType,
-        tacEP:       EPS[Method, TACAI]
-    ): ProperPropertyComputationResult
-}

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/cg/xta/ArrayInstantiationsAnalysis.scala

@@ -43,7 +43,7 @@ import org.opalj.tac.fpcf.properties.TACAI
 final class ArrayInstantiationsAnalysis(
     val project:     SomeProject,
     selectSetEntity: TypeSetEntitySelector
-) extends DefinedBodyReachableMethodAnalysis {
+) extends ReachableMethodAnalysis {
 
     override def processMethod(
         callContext: ContextType,

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/cg/xta/TypePropagationAnalysis.scala

@@ -56,7 +56,7 @@ import org.opalj.tac.fpcf.properties.TACAI
 final class TypePropagationAnalysis private[analyses] (
     val project:         SomeProject,
     selectTypeSetEntity: TypeSetEntitySelector
-) extends DefinedBodyReachableMethodAnalysis {
+) extends ReachableMethodAnalysis {
 
     private[this] val debug = false
     private[this] val _trace: TypePropagationTrace = new TypePropagationTrace()

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/fieldaccess/FieldAccessInformationAnalysis.scala

@@ -37,7 +37,7 @@ import org.opalj.fpcf.Results
 import org.opalj.fpcf.SomeEPS
 import org.opalj.fpcf.UBP
 import org.opalj.tac.fpcf.analyses.cg.BaseAnalysisState
-import org.opalj.tac.fpcf.analyses.cg.DefinedBodyReachableMethodAnalysis
+import org.opalj.tac.fpcf.analyses.cg.ReachableMethodAnalysis
 import org.opalj.tac.fpcf.analyses.cg.persistentUVar
 import org.opalj.tac.fpcf.properties.TACAI
 import org.opalj.tac.fpcf.properties.TheTACAI
@@ -166,7 +166,7 @@ private[fieldaccess] class EagerTacBasedFieldAccessInformationAnalysis(
 
 private[fieldaccess] class ReachableTacBasedFieldAccessInformationAnalysis(
     val project: SomeProject
-) extends FieldAccessInformationAnalysis with DefinedBodyReachableMethodAnalysis {
+) extends FieldAccessInformationAnalysis with ReachableMethodAnalysis {
 
     override def processMethod(callContext: ContextType, tacEP: EPS[Method, TACAI]): ProperPropertyComputationResult = {
         implicit val state: State = new State(callContext, tacEP)

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/pointsto/AbstractPointsToAnalysis.scala

@@ -51,7 +51,7 @@ import org.opalj.fpcf.UBP
 import org.opalj.log.OPALLogger.logOnce
 import org.opalj.log.Warn
 import org.opalj.tac.common.DefinitionSite
-import org.opalj.tac.fpcf.analyses.cg.DefinedBodyReachableMethodAnalysis
+import org.opalj.tac.fpcf.analyses.cg.ReachableMethodAnalysis
 import org.opalj.tac.fpcf.properties.TACAI
 import org.opalj.value.IsMultipleReferenceValue
 import org.opalj.value.IsReferenceValue
@@ -64,7 +64,7 @@ import org.opalj.value.ValueInformation
  *
  * @author Florian Kuebler
  */
-trait AbstractPointsToAnalysis extends PointsToAnalysisBase with DefinedBodyReachableMethodAnalysis {
+trait AbstractPointsToAnalysis extends PointsToAnalysisBase with ReachableMethodAnalysis {
 
     override def processMethod(
         callContext: ContextType,