fix(core): Base only analysis

core/opentaint-configuration-rules/configuration-rules-common/src/main/kotlin/org/opentaint/dataflow/configuration/ConditionSimplifier.kt

@@ -57,6 +57,7 @@ private class ConditionSimplifierImpl<A> : CommonConditionVisitor<A, CommonCondi
 }
 
 private val conditionSimplifier = ConditionSimplifierImpl<Nothing>()
+private val falseCondition: CommonCondition<Nothing> = Not(CommonCondition.True)
 
 @Suppress("UNCHECKED_CAST")
 fun <A> conditionSimplifier(): CommonConditionVisitor<A, CommonCondition<A>> =
@@ -66,7 +67,9 @@ fun <A> conditionSimplifier(): CommonConditionVisitor<A, CommonCondition<A>> =
 fun <A> mkTrue(): CommonCondition<A> =
     CommonCondition.True as CommonCondition<A>
 
-fun <A> mkFalse(): CommonCondition<A> = Not(mkTrue())
+@Suppress("UNCHECKED_CAST")
+fun <A> mkFalse(): CommonCondition<A> =
+    falseCondition as CommonCondition<A>
 
 fun <A> mkOr(conditions: List<CommonCondition<A>>) = when (conditions.size) {
     0 -> mkFalse()

core/opentaint-configuration-rules/configuration-rules-common/src/test/kotlin/org/opentaint/dataflow/configuration/ConditionFactoryTest.kt

@@ -0,0 +1,14 @@
+package org.opentaint.dataflow.configuration
+
+import kotlin.test.Test
+import kotlin.test.assertSame
+
+class ConditionFactoryTest {
+    @Test
+    fun `false condition is shared`() {
+        val first: Any = mkFalse<String>()
+        val second: Any = mkFalse<Int>()
+
+        assertSame(first, second)
+    }
+}

core/opentaint-dataflow-core/opentaint-dataflow/src/main/java/org/opentaint/dataflow/util/ConcurrentReadSafeLong2ObjectMap.java

@@ -0,0 +1,75 @@
+package org.opentaint.dataflow.util;
+
+import it.unimi.dsi.fastutil.HashCommon;
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A primitive long map with point reads that tolerate a concurrent rehash.
+ *
+ * <p>The supported concurrency model is one writer and any number of readers. Removals are not
+ * supported. Iteration must use the captured-table helper in {@code MapUtils.kt}; the inherited
+ * fastutil iterators are not concurrent-read-safe.</p>
+ */
+public final class ConcurrentReadSafeLong2ObjectMap<V> extends Long2ObjectOpenHashMap<V> {
+    @Override
+    public @Nullable V get(long k) {
+        if (k == 0) {
+            if (!containsNullKey) return defRetValue;
+
+            do {
+                int n = this.n;
+                V[] value = this.value;
+                if (value.length == n + 1) return value[n];
+            } while (true);
+        }
+
+        while (true) {
+            long[] key = this.key;
+            V[] value = this.value;
+            int n = this.n;
+
+            // Capture a matching table generation to allow a read during rehash.
+            if (key.length != n + 1 || value.length != n + 1) continue;
+
+            int mask = n - 1;
+            int pos = (int) HashCommon.mix(k) & mask;
+            long curr = key[pos];
+            if (curr == 0) return defRetValue;
+
+            if (k == curr) return value[pos];
+
+            // There's always an unused entry.
+            while (true) {
+                pos = (pos + 1) & mask;
+                curr = key[pos];
+                if (curr == 0) return defRetValue;
+
+                if (k == curr) return value[pos];
+            }
+        }
+    }
+
+    @Override
+    public V remove(long k) {
+        throw new UnsupportedOperationException("Removals are not allowed");
+    }
+
+    public long[] getKeys() {
+        return this.key;
+    }
+
+    public V[] getValues() {
+        return this.value;
+    }
+
+    public int getN() {
+        return this.n;
+    }
+
+    public boolean getContainsNullKey() {
+        return this.containsNullKey;
+    }
+
+    private static final long serialVersionUID = 0L;
+}

core/opentaint-dataflow-core/opentaint-dataflow/src/main/java/org/opentaint/dataflow/util/ConcurrentReadSafeLongSet.java

@@ -0,0 +1,61 @@
+package org.opentaint.dataflow.util;
+
+import it.unimi.dsi.fastutil.HashCommon;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+
+/**
+ * A primitive long set with point reads that tolerate a concurrent rehash.
+ *
+ * <p>The supported concurrency model is one writer and any number of readers. Removals are not
+ * supported. Iteration must use the captured-table helper in {@code MapUtils.kt}; the inherited
+ * fastutil iterators are not concurrent-read-safe.</p>
+ */
+public final class ConcurrentReadSafeLongSet extends LongOpenHashSet {
+    @Override
+    public boolean contains(long k) {
+        if (k == 0) return containsNull;
+
+        while (true) {
+            long[] key = this.key;
+            int n = this.n;
+
+            // Capture one complete table generation to allow a read during rehash.
+            if (key.length != n + 1) continue;
+
+            int mask = n - 1;
+            int pos = (int) HashCommon.mix(k) & mask;
+            long curr = key[pos];
+            if (curr == 0) return false;
+
+            if (k == curr) return true;
+
+            // There's always an unused entry.
+            while (true) {
+                pos = (pos + 1) & mask;
+                curr = key[pos];
+                if (curr == 0) return false;
+
+                if (k == curr) return true;
+            }
+        }
+    }
+
+    @Override
+    public boolean remove(long k) {
+        throw new UnsupportedOperationException("Removals are not allowed");
+    }
+
+    public long[] getKeys() {
+        return this.key;
+    }
+
+    public int getN() {
+        return this.n;
+    }
+
+    public boolean getContainsNull() {
+        return this.containsNull;
+    }
+
+    private static final long serialVersionUID = 0L;
+}

core/opentaint-dataflow-core/opentaint-dataflow/src/main/java/org/opentaint/dataflow/util/ConcurrentReadSafeObject2IntMap.java

@@ -4,56 +4,83 @@
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 import org.jetbrains.annotations.Nullable;
 
+/**
+ * A flat object-to-int map supporting one writer and multiple concurrent point readers.
+ *
+ * <p>Writes are published through a sequence counter. Readers retry if a write overlaps their
+ * lookup, which prevents observing a key before its primitive value or a partially published
+ * rehash. Removals are not supported.</p>
+ */
 public final class ConcurrentReadSafeObject2IntMap<K> extends Object2IntOpenHashMap<K> {
     public static final int NO_VALUE = -1;
 
+    private volatile long writeSequence;
+
     public ConcurrentReadSafeObject2IntMap() {
         super();
         defaultReturnValue(NO_VALUE);
     }
 
     @Override
     public int getInt(@Nullable Object k) {
-        if (k == null) {
-            if (!containsNullKey) return defRetValue;
-
-            do {
-                int n = this.n;
-                int[] value = this.value;
-                if (value.length == n + 1) return value[n];
-            } while (true);
-        }
-
         while (true) {
+            long sequenceBefore = writeSequence;
+            if ((sequenceBefore & 1) != 0) continue;
+
             K[] key = this.key;
             int[] value = this.value;
             int n = this.n;
+            int result = findValue(k, key, value, n);
 
-            // capture arrays to allow concurrent reads
-            if (key.length != n + 1 || value.length != n + 1) continue;
+            if (sequenceBefore == writeSequence) return result;
+        }
+    }
 
-            int mask = n - 1;
+    private int findValue(@Nullable Object k, K[] key, int[] value, int n) {
+        if (k == null) return containsNullKey ? value[n] : defRetValue;
 
-            // The starting point.
-            int pos = HashCommon.mix(k.hashCode()) & mask;
+        int mask = n - 1;
+        int pos = HashCommon.mix(k.hashCode()) & mask;
+        K curr = key[pos];
+        if (curr == null) return defRetValue;
+        if (k.equals(curr)) return value[pos];
 
-            K curr = key[pos];
+        while (true) {
+            pos = (pos + 1) & mask;
+            curr = key[pos];
             if (curr == null) return defRetValue;
-
             if (k.equals(curr)) return value[pos];
+        }
+    }
 
-            // There's always an unused entry.
-            while (true) {
-                pos = (pos + 1) & mask;
-
-                curr = key[pos];
-                if (curr == null) return defRetValue;
+    @Override
+    public int put(K key, int value) {
+        beginWrite();
+        try {
+            return super.put(key, value);
+        } finally {
+            endWrite();
+        }
+    }
 
-                if (k.equals(curr)) return value[pos];
-            }
+    @Override
+    public int putIfAbsent(K key, int value) {
+        beginWrite();
+        try {
+            return super.putIfAbsent(key, value);
+        } finally {
+            endWrite();
         }
     }
 
+    private void beginWrite() {
+        writeSequence++;
+    }
+
+    private void endWrite() {
+        writeSequence++;
+    }
+
     @Override
     public int removeInt(Object k) {
         throw new UnsupportedOperationException("Removals are not allowed");

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/AnalysisRunner.kt

@@ -17,6 +17,7 @@ interface AnalysisRunner {
     val methodCallResolver: MethodCallResolver
 
     fun enqueueMethodAnalyzer(analyzer: MethodAnalyzer)
+    fun reprioritizeMethodAnalyzer(analyzer: MethodAnalyzer)
     fun registerDelayedAnalyzer(analyzer: MethodAnalyzer)
     fun addNewSummaryEdges(methodEntryPoint: MethodEntryPoint, edges: List<Edge>)
     fun getPrecalculatedSummaries(methodEntryPoint: MethodEntryPoint): Pair<List<Edge>, List<InitialFactAp>>?

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/AnalysisUnitRunnerManager.kt

@@ -14,6 +14,7 @@ interface AnalysisUnitRunnerManager {
     fun getOrCreateUnitStorage(unit: UnitType): MethodSummariesUnitStorage?
     fun getOrCreateUnitRunner(unit: UnitType): AnalysisRunner?
     fun registerMethodCallFromUnit(method: CommonMethod, unit: UnitType)
+    fun registerResolvedMethodCall(caller: CommonMethod, callee: CommonMethod)
 
     fun handleCrossUnitZeroCall(callerUnit: UnitType, methodEntryPoint: MethodEntryPoint) {
         handleCrossUnitAction(callerUnit, methodEntryPoint) {
@@ -109,6 +110,15 @@ interface AnalysisUnitRunnerManager {
         return storage.methodFactToFactSummaryEdges(methodEntryPoint, finalFactBase)
     }
 
+    fun findFactToFactSummaryEdges(
+        methodEntryPoint: MethodEntryPoint,
+        finalFactPattern: FinalFactAp,
+    ): List<Edge.FactToFact> {
+        val unit = unitResolver.resolve(methodEntryPoint.method)
+        val storage = getOrCreateUnitStorage(unit) ?: return emptyList()
+        return storage.methodFactToFactSummaryEdges(methodEntryPoint, finalFactPattern)
+    }
+
     fun findFactNDSummaryEdges(
         methodEntryPoint: MethodEntryPoint,
         finalFactBase: AccessPathBase

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/EdgeCollection.kt

@@ -7,6 +7,34 @@ import org.opentaint.dataflow.ap.ifds.access.InitialFactAp
 import org.opentaint.ir.api.common.cfg.CommonInst
 
 object EdgeCollection {
+    class UnprocessedEdgeList(
+        apManager: ApManager,
+        methodEntryPoint: MethodEntryPoint,
+    ) {
+        private val zeroToZeroEdges = arrayListOf<Edge.ZeroToZero>()
+        private val otherEdges = EdgeList(apManager, methodEntryPoint)
+
+        val containsZeroToZeroEdges: Boolean
+            get() = zeroToZeroEdges.isNotEmpty()
+
+        val isEmpty: Boolean
+            get() = zeroToZeroEdges.isEmpty() && otherEdges.isEmpty
+
+        val size: Int
+            get() = zeroToZeroEdges.size + otherEdges.size
+
+        fun add(edge: Edge) {
+            if (edge is Edge.ZeroToZero) {
+                zeroToZeroEdges.add(edge)
+            } else {
+                otherEdges.add(edge)
+            }
+        }
+
+        fun removeLast(): Edge =
+            zeroToZeroEdges.removeLastOrNull() ?: otherEdges.removeLast()
+    }
+
     class EdgeList(
         private val apManager: ApManager,
         private val methodEntryPoint: MethodEntryPoint