Feature/string analysis

DEVELOPING_OPAL/tools/src/main/scala/org/opalj/support/info/ClassUsageAnalysis.scala

@@ -4,25 +4,22 @@ package org.opalj.support.info
 import scala.annotation.switch
 
 import java.net.URL
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.atomic.AtomicInteger
 
+import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 
 import org.opalj.log.GlobalLogContext
-import org.opalj.value.ValueInformation
+import org.opalj.log.OPALLogger
 import org.opalj.br.analyses.BasicReport
 import org.opalj.br.analyses.Project
 import org.opalj.br.analyses.ProjectAnalysisApplication
 import org.opalj.br.analyses.ReportableAnalysisResult
 import org.opalj.tac.Assignment
 import org.opalj.tac.Call
-import org.opalj.tac.DUVar
 import org.opalj.tac.ExprStmt
-import org.opalj.tac.LazyDetachedTACAIKey
-import org.opalj.tac.NonVirtualMethodCall
-import org.opalj.tac.StaticMethodCall
-import org.opalj.tac.VirtualMethodCall
+import org.opalj.tac.VirtualFunctionCall
+import org.opalj.tac.fpcf.analyses.cg.V
+import org.opalj.tac.EagerDetachedTACAIKey
 
 /**
  * Analyzes a project for how a particular class is used within that project. Collects information
@@ -34,28 +31,41 @@ import org.opalj.tac.VirtualMethodCall
  * [[ClassUsageAnalysis.analysisSpecificParametersDescription]].
  *
  * @author Patrick Mell
- * @author Dominik Helm
  */
 object ClassUsageAnalysis extends ProjectAnalysisApplication {
 
-    private type V = DUVar[ValueInformation]
-
     implicit val logContext: GlobalLogContext.type = GlobalLogContext
 
     override def title: String = "Class Usage Analysis"
 
     override def description: String = {
-        "Analyzes a project for how a particular class is used within it, i.e., which methods "+
-            "of instances of that class are called"
+        "Analysis a project for how a particular class is used, i.e., which methods are called "+
+            "on it"
     }
 
+    /**
+     * The fully-qualified name of the class that is to be analyzed in a Java format, i.e., dots as
+     * package / class separators.
+     */
+    private var className = "java.lang.StringBuilder"
+
+    /**
+     * The analysis can run in two modes: Fine-grained or coarse-grained. Fine-grained means that
+     * two method are considered as the same only if their method descriptor is the same, i.e., this
+     * mode enables a differentiation between overloaded methods.
+     * The coarse-grained method, however, regards two method calls as the same if the class of the
+     * base object as well as the method name are equal, i.e., overloaded methods are not
+     * distinguished.
+     */
+    private var isFineGrainedAnalysis = false
+
     /**
      * Takes a [[Call]] and assembles the method descriptor for this call. The granularity is
      * determined by [[isFineGrainedAnalysis]]: For a fine-grained analysis, the returned string has
      * the format "[fully-qualified classname]#[method name]: [stringified method descriptor]" and
      * for a coarse-grained analysis: [fully-qualified classname]#[method name].
      */
-    private def assembleMethodDescriptor(call: Call[V], isFineGrainedAnalysis: Boolean): String = {
+    private def assembleMethodDescriptor(call: Call[V]): String = {
         val fqMethodName = s"${call.declaringClass.toJava}#${call.name}"
         if (isFineGrainedAnalysis) {
             val methodDescriptor = call.descriptor.toString
@@ -66,44 +76,28 @@ object ClassUsageAnalysis extends ProjectAnalysisApplication {
     }
 
     /**
-     * Takes any [[Call]], checks whether the base object is of type [[className]] and if so,
-     * updates the passed map by adding the count of the corresponding method. The granularity for
-     * counting is determined by [[isFineGrainedAnalysis]].
+     * Takes any function [[Call]], checks whether the base object is of type [[className]] and if
+     * so, updates the passed map by adding the count of the corresponding method. The granularity
+     * for counting is determined by [[isFineGrainedAnalysis]].
      */
-    private def processCall(
-        call:                  Call[V],
-        map:                   ConcurrentHashMap[String, AtomicInteger],
-        className:             String,
-        isFineGrainedAnalysis: Boolean
-    ): Unit = {
+    private def processFunctionCall(call: Call[V], map: mutable.Map[String, Int]): Unit = {
         val declaringClassName = call.declaringClass.toJava
         if (declaringClassName == className) {
-            val methodDescriptor = assembleMethodDescriptor(call, isFineGrainedAnalysis)
-            if (map.putIfAbsent(methodDescriptor, new AtomicInteger(1)) != null) {
-                map.get(methodDescriptor).addAndGet(1)
+            val methodDescriptor = assembleMethodDescriptor(call)
+            if (map.contains(methodDescriptor)) {
+                map(methodDescriptor) += 1
+            } else {
+                map(methodDescriptor) = 1
             }
         }
     }
 
     override def analysisSpecificParametersDescription: String = {
-        "-class=<fully-qualified class name> \n"+
+        "[-class=<fully-qualified class name>  (Default: java.lang.StringBuilder)]\n"+
             "[-granularity=<fine|coarse> (Default: coarse)]"
     }
 
-    /**
-     * The fully-qualified name of the class that is to be analyzed in a Java format, i.e., dots as
-     * package / class separators.
-     */
     private final val parameterNameForClass = "-class="
-
-    /**
-     * The analysis can run in two modes: Fine-grained or coarse-grained. Fine-grained means that
-     * two methods are considered equal iff their method descriptor is the same, i.e., this mode
-     * enables a differentiation between overloaded methods.
-     * The coarse-grained method, however, regards two method calls as the same if the class of the
-     * base object as well as the method name are equal, i.e., overloaded methods are not
-     * distinguished.
-     */
     private final val parameterNameForGranularity = "-granularity="
 
     override def checkAnalysisSpecificParameters(parameters: Seq[String]): Traversable[String] = {
@@ -118,60 +112,58 @@ object ClassUsageAnalysis extends ProjectAnalysisApplication {
      * Takes the parameters passed as program arguments, i.e., in the format
      * "-[param name]=[value]", extracts the values and sets the corresponding object variables.
      */
-    private def getAnalysisParameters(parameters: Seq[String]): (String, Boolean) = {
+    private def setAnalysisParameters(parameters: Seq[String]): Unit = {
         val classParam = parameters.find(_.startsWith(parameterNameForClass))
-        val className = if (classParam.isDefined) {
-            classParam.get.substring(classParam.get.indexOf("=") + 1)
-        } else {
-            throw new IllegalArgumentException("missing argument: -class")
+        if (classParam.isDefined) {
+            className = classParam.get.substring(classParam.get.indexOf("=") + 1)
         }
 
         val granularityParam = parameters.find(_.startsWith(parameterNameForGranularity))
-        val isFineGrainedAnalysis =
-            if (granularityParam.isDefined) {
-                granularityParam.get.substring(granularityParam.get.indexOf("=") + 1) match {
-                    case "fine"   ⇒ true
-                    case "coarse" ⇒ false
-                    case _ ⇒
-                        val msg = "incorrect argument: -granularity must be one of fine|coarse"
-                        throw new IllegalArgumentException(msg)
-                }
+        if (granularityParam.isDefined) {
+            val granularity = granularityParam.get.substring(granularityParam.get.indexOf("=") + 1)
+            if (granularity == "fine") {
+                isFineGrainedAnalysis = true
+            } else if (granularity == "coarse") {
+                isFineGrainedAnalysis = false
             } else {
-                false // default is coarse grained
+                val errMsg = s"failed parsing the granularity; it must be either 'fine' or "+
+                    s"'coarse' but got '$granularity'"
+                OPALLogger.error("fatal", errMsg)
+                sys.exit(2)
             }
-
-        (className, isFineGrainedAnalysis)
+        }
     }
 
     override def doAnalyze(
         project: Project[URL], parameters: Seq[String], isInterrupted: () ⇒ Boolean
     ): ReportableAnalysisResult = {
-        val (className, isFineGrainedAnalysis) = getAnalysisParameters(parameters)
-        val resultMap: ConcurrentHashMap[String, AtomicInteger] = new ConcurrentHashMap()
-        val tacProvider = project.get(LazyDetachedTACAIKey)
+        setAnalysisParameters(parameters)
+        val resultMap = mutable.Map[String, Int]()
+        val tacProvider = project.get(EagerDetachedTACAIKey)
 
-        project.parForeachMethodWithBody() { methodInfo ⇒
-            tacProvider(methodInfo.method).stmts.foreach { stmt ⇒
+        project.allMethodsWithBody.foreach { m ⇒
+            tacProvider(m).stmts.foreach { stmt ⇒
                 (stmt.astID: @switch) match {
-                    case Assignment.ASTID | ExprStmt.ASTID ⇒
-                        stmt.asAssignmentLike.expr match {
-                            case c: Call[V] @unchecked ⇒
-                                processCall(c, resultMap, className, isFineGrainedAnalysis)
-                            case _ ⇒
-                        }
-                    case NonVirtualMethodCall.ASTID | VirtualMethodCall.ASTID |
-                        StaticMethodCall.ASTID ⇒
-                        processCall(stmt.asMethodCall, resultMap, className, isFineGrainedAnalysis)
+                    case Assignment.ASTID ⇒ stmt match {
+                        case Assignment(_, _, c: VirtualFunctionCall[V]) ⇒
+                            processFunctionCall(c, resultMap)
+                        case _ ⇒
+                    }
+                    case ExprStmt.ASTID ⇒ stmt match {
+                        case ExprStmt(_, c: VirtualFunctionCall[V]) ⇒
+                            processFunctionCall(c, resultMap)
+                        case _ ⇒
+                    }
                     case _ ⇒
                 }
             }
         }
 
-        val report = ListBuffer[String]("Result:")
-        // Transform to a list, sort in ascending order of occurrences, and format the information
-        resultMap.entrySet().stream().sorted { (value1, value2) ⇒
-            value1.getValue.get().compareTo(value2.getValue.get())
-        }.forEach(next ⇒ report.append(s"${next.getKey}: ${next.getValue}"))
+        val report = ListBuffer[String]("Results")
+        // Transform to a list, sort in ascending order of occurrences and format the information
+        report.appendAll(resultMap.toList.sortWith(_._2 < _._2).map {
+            case (descriptor: String, count: Int) ⇒ s"$descriptor: $count"
+        })
         BasicReport(report)
     }