Remove spurious inheritance

Author: Dominik Helm

OPAL/si/src/main/scala/org/opalj/fpcf/AnalysisScenario.scala

@@ -329,59 +329,6 @@ class AnalysisScenario[A](val ps: PropertyStore) {
             initializationData
         )
     }
-
-    /**
-     * Computes the configuration for a specific batch; this method can only handle the situation
-     * where all analyses can be executed in the same phase.
-     */
-    protected def computePhase(
-        propertyStore:     PropertyStore,
-        phaseAnalysis:     Set[ComputationSpecification[A]],
-        nextPhaseAnalysis: Set[ComputationSpecification[A]]
-    ): PhaseConfiguration[A] = {
-
-        // 1. compute the phase configuration; i.e., find those properties for which we must
-        //    suppress interim updates.
-        var suppressInterimUpdates: Map[PropertyKind, Set[PropertyKind]] = Map.empty
-        // Interim updates have to be suppressed when an analysis uses a property for which
-        // the wrong bounds/not enough bounds are computed.
-        transformersCS foreach { cs => suppressInterimUpdates += (cs.derivesLazily.get.pk -> cs.uses(ps).map(_.pk)) }
-
-        def extractPropertyKinds(analyses: Set[ComputationSpecification[A]]): Set[PropertyKind] = {
-            analyses.flatMap { analysis =>
-                (analysis.derivesLazily.toSet ++
-                    analysis.derivesEagerly ++
-                    analysis.derivesCollaboratively ++
-                    analysis.derives.toSet)
-                    .map(_.pk)
-            }
-        }
-
-        val propertyKindsFromPhaseAnalysis = extractPropertyKinds(phaseAnalysis)
-        val propertyKindsFromNextPhaseAnalysis = extractPropertyKinds(nextPhaseAnalysis)
-
-        val collabProperties = phaseAnalysis.flatMap { analysis => analysis.derivesCollaboratively.map(_.pk) }
-
-        // 3. create the batch
-        val batchBuilder = List.newBuilder[ComputationSpecification[A]]
-        batchBuilder ++= phaseAnalysis
-
-        // FIXME...
-
-        // Interim updates can be suppressed when the depender and dependee are not in a cyclic
-        // relation; however, this could have a negative impact on the effect of deep laziness -
-        // once we are actually implementing it. For the time being, suppress notifications is always
-        // advantageous.
-
-        val phase1Configuration = PropertyKindsConfiguration(
-            propertyKindsComputedInThisPhase = propertyKindsFromPhaseAnalysis,
-            suppressInterimUpdates = suppressInterimUpdates,
-            propertyKindsComputedInLaterPhase = propertyKindsFromNextPhaseAnalysis,
-            collaborativelyComputedPropertyKindsFinalizationOrder = List(collabProperties.toList) // FIXME: Compute actual subphase finalization order
-        )
-
-        PhaseConfiguration(phase1Configuration, batchBuilder.result())
-    }
 }
 
 /**

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/IndependentPhaseMergeScheduling.scala

@@ -12,7 +12,7 @@ import org.opalj.graphs.topologicalSort
  * Merges independent batches to optimize parallelism.
  */
 class IndependentPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransformerInAllBatches: Boolean)
-    extends AnalysisScenario[A](ps) with SchedulingStrategy[A] {
+    extends SchedulingStrategy[A] {
 
     val name = "IPMS"
 

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/MaximumPhaseScheduling.scala

@@ -13,7 +13,7 @@ import org.opalj.graphs.topologicalSort
  */
 
 class MaximumPhaseScheduling[A](ps: PropertyStore, scheduleLazyTransformerInAllBatches: Boolean)
-    extends AnalysisScenario[A](ps) with SchedulingStrategy[A] {
+    extends SchedulingStrategy[A] {
 
     val name = "MPS"
 

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/SchedulingStrategy.scala

@@ -18,7 +18,58 @@ trait SchedulingStrategy[A] {
     ): List[PhaseConfiguration[A]]
 
     /**
-     * Common helper method for computing a phase/batch.
-     * Can be overridden by subclasses if needed.
+     * Computes the configuration for a specific batch; this method can only handle the situation
+     * where all analyses can be executed in the same phase.
      */
+    protected def computePhase(
+        ps:                   PropertyStore,
+        currentPhaseAnalyses: Set[ComputationSpecification[A]],
+        nextPhaseAnalyses:    Set[ComputationSpecification[A]]
+    ): PhaseConfiguration[A] = {
+
+        // 1. compute the phase configuration; i.e., find those properties for which we must
+        //    suppress interim updates.
+        var suppressInterimUpdates: Map[PropertyKind, Set[PropertyKind]] = Map.empty
+        // Interim updates have to be suppressed when an analysis uses a property for which
+        // the wrong bounds/not enough bounds are computed.
+        currentPhaseAnalyses foreach {
+            case cs if cs.computationType == Transformer =>
+                suppressInterimUpdates += (cs.derivesLazily.get.pk -> cs.uses(ps).map(_.pk))
+        }
+
+        def extractPropertyKinds(analyses: Set[ComputationSpecification[A]]): Set[PropertyKind] = {
+            analyses.flatMap { analysis =>
+                (analysis.derivesLazily.toSet ++
+                    analysis.derivesEagerly ++
+                    analysis.derivesCollaboratively ++
+                    analysis.derives.toSet)
+                    .map(_.pk)
+            }
+        }
+
+        val propertyKindsFromPhaseAnalysis = extractPropertyKinds(currentPhaseAnalyses)
+        val propertyKindsFromNextPhaseAnalysis = extractPropertyKinds(nextPhaseAnalyses)
+
+        val collabProperties = currentPhaseAnalyses.flatMap { analysis => analysis.derivesCollaboratively.map(_.pk) }
+
+        // 3. create the batch
+        val batchBuilder = List.newBuilder[ComputationSpecification[A]]
+        batchBuilder ++= currentPhaseAnalyses
+
+        // FIXME...
+
+        // Interim updates can be suppressed when the depender and dependee are not in a cyclic
+        // relation; however, this could have a negative impact on the effect of deep laziness -
+        // once we are actually implementing it. For the time being, suppress notifications is always
+        // advantageous.
+
+        val phase1Configuration = PropertyKindsConfiguration(
+            propertyKindsComputedInThisPhase = propertyKindsFromPhaseAnalysis,
+            suppressInterimUpdates = suppressInterimUpdates,
+            propertyKindsComputedInLaterPhase = propertyKindsFromNextPhaseAnalysis,
+            collaborativelyComputedPropertyKindsFinalizationOrder = List(collabProperties.toList) // FIXME: Compute actual subphase finalization order
+        )
+
+        PhaseConfiguration(phase1Configuration, batchBuilder.result())
+    }
 }

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/SinglePhaseScheduling.scala

@@ -7,7 +7,7 @@ package scheduling
  * Single Phase Scheduling (SPS) Strategy.
  * Schedules all computations in a single batch without considering dependencies.
  */
-class SinglePhaseScheduling[A](ps: PropertyStore) extends AnalysisScenario[A](ps) with SchedulingStrategy[A] {
+class SinglePhaseScheduling[A](ps: PropertyStore) extends SchedulingStrategy[A] {
 
     override def schedule(
         ps:    PropertyStore,

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/SmallestPhaseMergeScheduling.scala

@@ -12,7 +12,7 @@ import org.opalj.graphs.topologicalSort
  * Merging batches based on the number of analyses to keep merged batches of similar sizes.
  */
 class SmallestPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransformerInAllBatches: Boolean)
-    extends AnalysisScenario[A](ps) with SchedulingStrategy[A] {
+    extends SchedulingStrategy[A] {
 
     val name = "SPMS"