Use string analysis for more strings in reflect analysis

Author: Dominik Helm

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()
     }
 }
 

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

@@ -31,6 +31,7 @@ import org.opalj.br.fpcf.properties.cg.Callers
 import org.opalj.br.fpcf.properties.cg.ForNameClasses
 import org.opalj.br.fpcf.properties.cg.LoadedClasses
 import org.opalj.br.fpcf.properties.string.StringConstancyProperty
+import org.opalj.br.fpcf.properties.string.StringTreeNode
 import org.opalj.collection.immutable.IntTrieSet
 import org.opalj.collection.immutable.UIDSet
 import org.opalj.fpcf.Entity
@@ -254,8 +255,15 @@ class ClassForNameAnalysis private[analyses] (
         callContext: ContextType,
         stmts:       Array[Stmt[V]]
     )(implicit state: State): Unit = {
-        val possibleClasses =
-            TypesUtil.getPossibleForNameClasses(pc, className, callContext, stmts, project, allowDynamicStringTrees)
+        val possibleClasses = TypesUtil.getPossibleForNameClasses(
+            pc,
+            className,
+            callContext,
+            pc.asInstanceOf[Entity],
+            stmts,
+            project,
+            allowDynamicStringTrees
+        )
         state.addNewLoadedClasses(possibleClasses)
     }
 
@@ -750,7 +758,6 @@ class MethodInvokeAnalysis private[analyses] (
         Option[(ValueInformation, IntTrieSet)],
         Seq[Option[(ValueInformation, IntTrieSet)]],
         Set[MethodMatcher],
-        V,
         Array[Stmt[V]],
         V,
         ContextType
@@ -770,6 +777,8 @@ class MethodInvokeAnalysis private[analyses] (
 
         val epk = eps.toEPK
 
+        implicit val highSoundness: Boolean = HighSoundnessMode("method")
+
         if (epk.pk == ForNameClasses.key) {
             val (callPC, receiver, params, matchers, _, _) = state.dependersOf(epk).head.asInstanceOf[classDependerType]
 
@@ -781,9 +790,22 @@ class MethodInvokeAnalysis private[analyses] (
                 new ClassBasedMethodMatcher(classes, !matchers.contains(PublicMethodMatcher))
 
             addCalls(state.callContext, callPC, _ => receiver, params, allMatchers)
-        } else {
-            implicit val highSoundness: Boolean = HighSoundnessMode("method")
+        } else if (epk.pk == StringConstancyProperty.key) {
+            state.dependersOf(epk).foreach {
+                case depender: nameDependerType @unchecked if depender.isInstanceOf[nameDependerType] =>
+                    val (callPC, actualReceiver, actualParams, matchers, _, _, _) = depender
+                    val nameMatcher = retrieveSuitableMatcher[StringTreeNode](
+                        Some(eps.ub.asInstanceOf[StringConstancyProperty].tree),
+                        callPC,
+                        v => new NameBasedMethodMatcher(v)
+                    )
 
+                    if (nameMatcher ne NoMethodsMatcher) {
+                        val allMatchers = matchers + getClassMatcher(depender, matchers + nameMatcher)
+                        addCalls(state.callContext, callPC, _ => actualReceiver, actualParams, allMatchers)
+                    }
+            }
+        } else {
             AllocationsUtil.continuationForAllocation[methodDependerType, ContextType](
                 eps,
                 state.callContext,
@@ -796,30 +818,6 @@ class MethodInvokeAnalysis private[analyses] (
                 addCalls(state.callContext, data._1, _ => data._2, data._3, allMatchers)
             }
 
-            AllocationsUtil.continuationForAllocation[nameDependerType, ContextType](
-                eps,
-                state.callContext,
-                data => (data._5, data._6),
-                _.isInstanceOf[(_, _, _, _, _, _, _, _)],
-                data => {
-                    val allMatchers = data._4 + getClassMatcher(data, data._4)
-                    failure("method", data._1, data._2, data._3, allMatchers)
-                }
-            ) { (data, _, allocationIndex, stmts) =>
-                val name = StringUtil.getString(allocationIndex, stmts)
-
-                val nameMatcher = retrieveSuitableMatcher[Set[String]](
-                    name.map(Set(_)),
-                    data._1,
-                    v => new NameBasedMethodMatcher(v)
-                )
-
-                if (nameMatcher ne NoMethodsMatcher) {
-                    val allMatchers = data._4 + getClassMatcher(data, data._4 + nameMatcher)
-                    addCalls(state.callContext, data._1, _ => data._2, data._3, allMatchers)
-                }
-            }
-
             AllocationsUtil.continuationForAllocation[classDependerType, ContextType](
                 eps,
                 state.callContext,
@@ -863,11 +861,11 @@ class MethodInvokeAnalysis private[analyses] (
     )(implicit state: TACAIBasedCGState[ContextType], indirectCalls: IndirectCalls): MethodMatcher = {
         implicit val highSoundness: Boolean = HighSoundnessMode("class")
         MatcherUtil.retrieveClassBasedMethodMatcher(
-            data._8,
             data._7,
-            (data._1, data._2, data._3, matchers, data._7, data._6),
-            data._1,
             data._6,
+            (data._1, data._2, data._3, matchers, data._6, data._5),
+            data._1,
+            data._5,
             project,
             () => failure("class", data._1, data._2, data._3, matchers),
             onlyMethodsExactlyInClass = !matchers.contains(PublicMethodMatcher)
@@ -965,16 +963,15 @@ class MethodInvokeAnalysis private[analyses] (
                 var failed: String = null
 
                 val depender =
-                    (callPC, actualReceiver, actualParams, matchers, params.head.asVar, stmts, receiver.asVar, context)
+                    (callPC, actualReceiver, actualParams, matchers, stmts, receiver.asVar, context)
 
                 if (!matchers.contains(NoMethodsMatcher))
                     matchers += MatcherUtil.retrieveNameBasedMethodMatcher(
-                        context,
+                        callPC,
                         params.head.asVar,
+                        context,
                         depender,
-                        callPC,
-                        stmts,
-                        () => failed = "method"
+                        stmts
                     )
 
                 if (!matchers.contains(NoMethodsMatcher))
@@ -1087,7 +1084,6 @@ class MethodHandleInvokeAnalysis private[analyses] (
         Boolean,
         Seq[Option[(ValueInformation, IntTrieSet)]],
         Set[MethodMatcher],
-        V,
         Array[Stmt[V]],
         V,
         ContextType
@@ -1101,6 +1097,8 @@ class MethodHandleInvokeAnalysis private[analyses] (
 
         val epk = eps.toEPK
 
+        implicit val highSoundness: Boolean = HighSoundnessMode("method")
+
         if (epk.pk == ForNameClasses.key) {
             val (callPC, isVirtual, params, matchers, _, _) = state.dependersOf(epk).head.asInstanceOf[classDependerType]
 
@@ -1113,9 +1111,24 @@ class MethodHandleInvokeAnalysis private[analyses] (
             val allMatchers = matchers + new ClassBasedMethodMatcher(classes, false)
 
             addCalls(state.callContext, callPC, allMatchers, params)
-        } else {
-            implicit val highSoundness: Boolean = HighSoundnessMode("method")
+        } else if (epk.pk == StringConstancyProperty.key) {
+            state.dependersOf(epk).foreach {
+                case depender: nameDependerType @unchecked if depender.isInstanceOf[nameDependerType] =>
+                    val (callPC, _, actualParams, previousMatchers, _, _, _) = depender
 
+                    val nameMatcher = retrieveSuitableMatcher[StringTreeNode](
+                        Some(eps.ub.asInstanceOf[StringConstancyProperty].tree),
+                        callPC,
+                        v => new NameBasedMethodMatcher(v)
+                    )
+
+                    if (nameMatcher ne NoMethodsMatcher) {
+                        val matchers = previousMatchers + nameMatcher
+                        val allMatchers = matchers + getClassMatcher(depender, matchers)
+                        addCalls(state.callContext, callPC, allMatchers, actualParams)
+                    }
+            }
+        } else {
             AllocationsUtil.continuationForAllocation[methodHandleDependerType, ContextType](
                 eps,
                 state.callContext,
@@ -1136,31 +1149,6 @@ class MethodHandleInvokeAnalysis private[analyses] (
                 addCalls(state.callContext, data._1, allMatchers, data._4)
             }
 
-            AllocationsUtil.continuationForAllocation[nameDependerType, ContextType](
-                eps,
-                state.callContext,
-                data => (data._5, data._6),
-                _.isInstanceOf[(_, _, _, _, _, _, _, _)],
-                data => {
-                    val allMatchers = data._4 + getClassMatcher(data, data._4)
-                    failure("method", data._1, data._3, allMatchers)
-                }
-            ) { (data, _, allocationIndex, stmts) =>
-                val name = StringUtil.getString(allocationIndex, stmts)
-
-                val nameMatcher = retrieveSuitableMatcher[Set[String]](
-                    name.map(Set(_)),
-                    data._1,
-                    v => new NameBasedMethodMatcher(v)
-                )
-
-                if (nameMatcher ne NoMethodsMatcher) {
-                    val matchers = data._4 + nameMatcher
-                    val allMatchers = matchers + getClassMatcher(data, matchers)
-                    addCalls(state.callContext, data._1, allMatchers, data._3)
-                }
-            }
-
             AllocationsUtil.continuationForAllocation[classDependerType, ContextType](
                 eps,
                 state.callContext,
@@ -1201,11 +1189,11 @@ class MethodHandleInvokeAnalysis private[analyses] (
     )(implicit state: TACAIBasedCGState[ContextType], indirectCalls: IndirectCalls): MethodMatcher = {
         implicit val highSoundness: Boolean = HighSoundnessMode("class")
         MatcherUtil.retrieveClassBasedMethodMatcher(
-            data._8,
             data._7,
-            (data._1, data._2, data._3, matchers, data._7, data._6),
-            data._1,
             data._6,
+            (data._1, data._2, data._3, matchers, data._6, data._5),
+            data._1,
+            data._5,
             project,
             () => failure("class", data._1, data._3, matchers),
             onlyMethodsExactlyInClass = false,
@@ -1410,12 +1398,11 @@ class MethodHandleInvokeAnalysis private[analyses] (
                     matchers +=
                         (if (isConstructor) MatcherUtil.constructorMatcher
                          else MatcherUtil.retrieveNameBasedMethodMatcher(
-                             context,
-                             name,
-                             (callPC, isVirtual, persistentActualParams, matchers, name, stmts, refc, context),
                              callPC,
-                             stmts,
-                             () => failure("method", callPC, persistentActualParams, matchers)
+                             name,
+                             context,
+                             (callPC, isVirtual, persistentActualParams, matchers, stmts, refc, context),
+                             stmts
                          ))
                 }
                 if (!matchers.contains(NoMethodsMatcher))
@@ -1446,7 +1433,7 @@ class MethodHandleInvokeAnalysis private[analyses] (
                                 onlyMethodsExactlyInClass = false
                             )
                         else {
-                            val data = (callPC, isVirtual, persistentActualParams, matchers, name, stmts, refc, context)
+                            val data = (callPC, isVirtual, persistentActualParams, matchers, stmts, refc, context)
                             matchers += getClassMatcher(data, matchers)
                         }
                     }