Use string analysis results for reflective calls

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/fpcf/analyses/StringAnalysisDemo.scala

@@ -0,0 +1,161 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj
+package fpcf
+package analyses
+
+import scala.language.postfixOps
+
+import java.io.File
+import java.net.URL
+
+import org.opalj.ai.domain.l1.DefaultDomainWithCFGAndDefUse
+import org.opalj.ai.fpcf.properties.AIDomainFactoryKey
+import org.opalj.br.analyses.BasicReport
+import org.opalj.br.analyses.DeclaredMethodsKey
+import org.opalj.br.analyses.Project
+import org.opalj.br.analyses.ProjectsAnalysisApplication
+import org.opalj.br.fpcf.ContextProviderKey
+import org.opalj.br.fpcf.analyses.ContextProvider
+import org.opalj.br.fpcf.cli.MultiProjectAnalysisConfig
+import org.opalj.br.fpcf.cli.StringAnalysisArg
+import org.opalj.br.fpcf.properties.Context
+import org.opalj.br.fpcf.properties.SimpleContextsKey
+import org.opalj.br.fpcf.properties.cg.Callees
+import org.opalj.br.fpcf.properties.string.StringConstancyProperty
+import org.opalj.cli.AnalysisLevelArg
+import org.opalj.fpcf.PropertyStoreBasedCommandLineConfig
+import org.opalj.tac.cg.AllocationSiteBasedPointsToCallGraphKey
+import org.opalj.tac.fpcf.analyses.cg.reflection.ReflectionRelatedCallsAnalysisScheduler
+import org.opalj.tac.fpcf.analyses.systemproperties.TriggeredSystemPropertiesAnalysisScheduler
+import org.opalj.util.PerformanceEvaluation.time
+import org.opalj.util.Seconds
+
+/**
+ * @author Maximilian Rüsch
+ */
+object StringAnalysisDemo extends ProjectsAnalysisApplication {
+
+    protected class StringAnalysisDemoConfig(args: Array[String]) extends MultiProjectAnalysisConfig(args)
+        with PropertyStoreBasedCommandLineConfig {
+        val description: String =
+            """
+              | Analyses the callees of the Main.entrypoint method of the given project,
+              | e.g. run with the DEVELOPING_OPAL/demos/src/main/resources/opal-xerces-playground.zip package.
+              |
+              | Also contains some live logging of runtime information about the property store.
+              |""".stripMargin
+
+        private val analysisLevelArg =
+            new AnalysisLevelArg(StringAnalysisArg.description, StringAnalysisArg.levels: _*) {
+                override val defaultValue: Option[String] = Some("trivial")
+                override val withNone = false
+            }
+
+        args(
+            analysisLevelArg !
+        )
+        init()
+
+        val analyses: Seq[FPCFAnalysisScheduler[_]] = {
+            StringAnalysisArg.getAnalyses(apply(analysisLevelArg)).map(getScheduler(_, eager = false))
+        }
+    }
+
+    protected type ConfigType = StringAnalysisDemoConfig
+
+    protected def createConfig(args: Array[String]): StringAnalysisDemoConfig = new StringAnalysisDemoConfig(args)
+
+    override protected def analyze(
+        cp:             Iterable[File],
+        analysisConfig: StringAnalysisDemoConfig,
+        execution:      Int
+    ): (Project[URL], BasicReport) = {
+        val (project, projectTime) = analysisConfig.setupProject()
+
+        val domain = classOf[DefaultDomainWithCFGAndDefUse[_]]
+        project.updateProjectInformationKeyInitializationData(AIDomainFactoryKey) {
+            case None               => Set(domain)
+            case Some(requirements) => requirements + domain
+        }
+
+        val cgKey = AllocationSiteBasedPointsToCallGraphKey
+        implicit val propertyStore: PropertyStore = project.get(PropertyStoreKey)
+        var analysisTime: Seconds = Seconds.None
+        val analysesManager = project.get(FPCFAnalysesManagerKey)
+        val typeIterator = cgKey.getTypeIterator(project)
+        project.updateProjectInformationKeyInitializationData(ContextProviderKey) { _ => typeIterator }
+
+        project.get(SimpleContextsKey)
+        time {
+            analysesManager
+                .runAll(
+                    cgKey.allCallGraphAnalyses(project)
+                        ++ analysisConfig.analyses
+                        ++ Seq(
+                            ReflectionRelatedCallsAnalysisScheduler,
+                            TriggeredSystemPropertiesAnalysisScheduler
+                        )
+                )
+            propertyStore.waitOnPhaseCompletion()
+        } { t => analysisTime = t.toSeconds }
+
+        val declaredMethods = project.get(DeclaredMethodsKey)
+        val entrypointMethod = project.allMethodsWithBody.find { m =>
+            m.name == "entrypoint" &&
+            m.classFile.thisType.fqn.endsWith("Main")
+        }.get
+        val dm = declaredMethods(entrypointMethod)
+
+        implicit val contextProvider: ContextProvider = project.get(ContextProviderKey)
+        val calleesUB = propertyStore(dm, Callees.key).ub
+        val calleesByPC = calleesUB.callerContexts.flatMap(calleesUB.callSites(_).iterator).toSeq
+        val incompleteCallSites = calleesUB.callerContexts.flatMap(calleesUB.incompleteCallSites(_)).toSeq
+
+        def getDepths(filter: Entity => Boolean): Seq[String] = {
+            val depths = propertyStore.entities(StringConstancyProperty.key)
+                .filter(eps => filter(eps.e))
+                .map(_.ub.tree.depth).toSeq
+
+            depths
+                .groupBy(depth => depth)
+                .transform((_: Int, counts) => counts.size)
+                .toSeq.sortBy(_._1)
+                .map(depthAndCount => s"Depth: ${depthAndCount._1}   Count: ${depthAndCount._2}")
+        }
+
+        def getMethodsList(contexts: Iterable[Context]): String = {
+            if (contexts.size > 50) "\n|     Too many contexts to display!"
+            else contexts.iterator
+                .map(c => s"- ${c.method.name} on ${c.method.declaringClassType.fqn}")
+                .mkString("\n|     ", "\n|     ", "")
+        }
+
+        def getPCMethodsList(pcContexts: Iterable[(Int, Iterator[Context])]): String = {
+            if (pcContexts.size > 50) "\n|     Too many pc contexts to display!"
+            else pcContexts.iterator
+                .map(c => s"  PC: ${c._1} ${getMethodsList(c._2.toSeq)}\n")
+                .mkString("\n|     ", "\n|     ", "")
+        }
+
+        (
+            project,
+            BasicReport(s"""
+           |
+           | Callees: ${calleesByPC.size} ${getPCMethodsList(calleesByPC)}
+           |
+           | Access Sites with missing information: $incompleteCallSites
+           |
+           | MethodParameterContext depths:
+           | ${getDepths(_.getClass.getName.endsWith("MethodParameterContext")).mkString("\n|     ", "\n|     ", "")}
+           |
+           | Context depths:
+           | ${getDepths(_.getClass.getName.endsWith("VariableContext")).mkString("\n|     ", "\n|     ", "")}
+           |
+           | Definition depths:
+           | ${getDepths(_.getClass.getName.endsWith("VariableDefinition")).mkString("\n|     ", "\n|     ", "")}
+           |
+           | took : $analysisTime seconds (and $projectTime seconds for project setup)
+           |""".stripMargin)
+        )
+    }
+}

OPAL/br/src/main/scala/org/opalj/br/PDUVar.scala

@@ -34,15 +34,18 @@ abstract class PDUVar[+Value <: ValueInformation] {
 }
 
 class PDVar[+Value <: ValueInformation /*org.opalj.ai.ValuesDomain#DomainValue*/ ] private (
-    val value:  Value,
-    val usePCs: PCs
+    val originPC: Int,
+    val value:    Value,
+    val usePCs:   PCs
 ) extends PDUVar[Value] {
 
     def defPCs: Nothing = throw new UnsupportedOperationException
 
+    override def hashCode(): Int = scala.util.hashing.MurmurHash3.productHash((originPC, usePCs))
+
     override def equals(other: Any): Boolean = {
         other match {
-            case that: PDVar[_] => this.usePCs == that.usePCs
+            case that: PDVar[_] => this.originPC == that.originPC && this.usePCs == that.usePCs
             case _              => false
         }
     }
@@ -54,9 +57,11 @@ class PDVar[+Value <: ValueInformation /*org.opalj.ai.ValuesDomain#DomainValue*/
 
 object PDVar {
 
-    def apply[Value <: ValueInformation](value: Value, useSites: IntTrieSet): PDVar[Value] = new PDVar(value, useSites)
+    def apply[Value <: ValueInformation](originSite: Int, value: Value, useSites: IntTrieSet): PDVar[Value] =
+        new PDVar(originSite, value, useSites)
 
-    def unapply[Value <: ValueInformation](d: PDVar[Value]): Some[(Value, IntTrieSet)] = Some((d.value, d.usePCs))
+    def unapply[Value <: ValueInformation](d: PDVar[Value]): Some[(Int, Value, IntTrieSet)] =
+        Some((d.originPC, d.value, d.usePCs))
 }
 
 class PUVar[+Value <: ValueInformation /*org.opalj.ai.ValuesDomain#DomainValue*/ ] private (
@@ -66,6 +71,8 @@ class PUVar[+Value <: ValueInformation /*org.opalj.ai.ValuesDomain#DomainValue*/
 
     def usePCs: Nothing = throw new UnsupportedOperationException
 
+    override def hashCode(): Int = defPCs.hashCode()
+
     override def equals(other: Any): Boolean = {
         other match {
             case that: PUVar[_] => this.defPCs == that.defPCs

OPAL/br/src/main/scala/org/opalj/br/fpcf/cli/StringAnalysisArg.scala

@@ -1,5 +1,8 @@
 /* BSD 2-Clause License - see OPAL/LICENSE for details. */
-package org.opalj.br.fpcf.cli
+package org.opalj
+package br
+package fpcf
+package cli
 
 import org.opalj.cli.AnalysisLevelArg
 

OPAL/tac/src/main/scala/org/opalj/tac/DUVar.scala

@@ -199,7 +199,7 @@ class DVar[+Value <: ValueInformation /*org.opalj.ai.ValuesDomain#DomainValue*/
 
     override def toPersistentForm(
         implicit stmts: Array[Stmt[V]]
-    ): PDVar[Value] = PDVar(value, usedBy.map(pcOfDefSite _))
+    ): PDVar[Value] = PDVar(pcOfDefSite(origin), value, usedBy.map(pcOfDefSite _))
 
 }
 

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

@@ -10,6 +10,8 @@ import org.opalj.br.ClassType
 import org.opalj.br.FieldTypes
 import org.opalj.br.analyses.SomeProject
 import org.opalj.br.fpcf.properties.Context
+import org.opalj.br.fpcf.properties.string.StringTreeConst
+import org.opalj.br.fpcf.properties.string.StringTreeNode
 import org.opalj.fpcf.Entity
 import org.opalj.fpcf.PropertyStore
 
@@ -86,29 +88,27 @@ object MatcherUtil {
      * provides allocation sites of Strings to be used as the method name.
      */
     private[reflection] def retrieveNameBasedMethodMatcher(
+        pc:       Int,
+        value:    V,
         context:  Context,
-        expr:     V,
         depender: Entity,
-        pc:       Int,
-        stmts:    Array[Stmt[V]],
-        failure:  () => Unit
+        stmts:    Array[Stmt[V]]
     )(
         implicit
-        typeIterator:        TypeIterator,
         state:               TypeIteratorState,
         ps:                  PropertyStore,
         incompleteCallSites: IncompleteCallSites,
         highSoundness:       Boolean
     ): MethodMatcher = {
-        val names = StringUtil.getPossibleStrings(expr, context, depender, stmts, failure)
-        retrieveSuitableMatcher[Set[String]](
-            Some(names),
+        val names = StringUtil.getPossibleStrings(pc, value, context, depender, stmts)
+        retrieveSuitableMatcher[StringTreeNode](
+            names,
             pc,
             v => new NameBasedMethodMatcher(v)
         )
     }
 
-    private[reflection] val constructorMatcher = new NameBasedMethodMatcher(Set("<init>"))
+    private[reflection] val constructorMatcher = new NameBasedMethodMatcher(StringTreeConst("<init>"))
 
     /**
      * Given an expression that evaluates to a Class<?> object, creates a MethodMatcher to match

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

@@ -12,6 +12,7 @@ import org.opalj.br.MethodDescriptor
 import org.opalj.br.ReferenceType
 import org.opalj.br.VoidType
 import org.opalj.br.analyses.SomeProject
+import org.opalj.br.fpcf.properties.string.StringTreeConst
 
 object MethodHandlesUtil {
     // TODO what about the case of an constructor?
@@ -36,7 +37,7 @@ object MethodHandlesUtil {
                         MethodDescriptor(desc.parameterTypes.tail, desc.returnType)
                 )
             ),
-            new NameBasedMethodMatcher(Set(name)),
+            new NameBasedMethodMatcher(StringTreeConst(name)),
             if (receiver.isArrayType)
                 new ClassBasedMethodMatcher(
                     Set(ClassType.Object),

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

@@ -6,15 +6,16 @@ package analyses
 package cg
 package reflection
 
+import java.util.regex.Pattern
 import scala.collection.immutable.ArraySeq
 
 import org.opalj.br.ClassHierarchy
 import org.opalj.br.ClassType
 import org.opalj.br.FieldTypes
 import org.opalj.br.Method
 import org.opalj.br.MethodDescriptor
-import org.opalj.br.analyses.ProjectIndexKey
 import org.opalj.br.analyses.SomeProject
+import org.opalj.br.fpcf.properties.string.StringTreeNode
 import org.opalj.value.IsReferenceValue
 
 /**
@@ -30,17 +31,17 @@ trait MethodMatcher {
     def contains(m: Method)(implicit p: SomeProject): Boolean
 }
 
-final class NameBasedMethodMatcher(val possibleNames: Set[String]) extends MethodMatcher {
+final class NameBasedMethodMatcher(val possibleNames: StringTreeNode) extends MethodMatcher {
+    val pattern = Pattern.compile(possibleNames.regex)
 
     override def initialMethods(implicit p: SomeProject): Iterator[Method] = {
-        val projectIndex = p.get(ProjectIndexKey)
-        possibleNames.iterator.flatMap(projectIndex.findMethods)
+        p.allMethods.filter(m => pattern.matcher(m.name).matches()).iterator
     }
 
     override def priority: Int = 2
 
     override def contains(m: Method)(implicit p: SomeProject): Boolean = {
-        possibleNames.contains(m.name)
+        pattern.matcher(m.name).matches()
     }
 }