Merge pull request github#6370 from owen-mc/java/model/apache-collections

Java: Model more of Apache Commons Collections

Author: owen-mc

java/change-notes/2021-07-27-apache-collections-base-package.md

@@ -0,0 +1,2 @@
+lgtm,codescanning
+* Added models for the base package of Apache Commons Collections. This may lead to more results from any query using data-flow analysis where a relevant path uses one of these container types.

java/ql/src/semmle/code/java/frameworks/apache/Collections.qll

@@ -9,6 +9,8 @@ class SummaryModelTest extends SummaryModelCsv {
     row =
       [
         //"package;type;overrides;name;signature;ext;inputspec;outputspec;kind",
+        // This is temporarily modelled for the helper function newEnumerationWithElement, until the relevant package is modelled
+        "org.apache.commons.collections4.iterators;IteratorEnumeration;true;IteratorEnumeration;;;Element of Argument[0];Element of Argument[-1];value",
         "generatedtest;Test;false;newRBWithMapValue;;;Argument[0];MapValue of ReturnValue;value",
         "generatedtest;Test;false;newRBWithMapKey;;;Argument[0];MapKey of ReturnValue;value"
       ]

java/ql/test/library-tests/frameworks/apache-collections/Test.java

@@ -0,0 +1,17 @@
+// Generated automatically from org.apache.commons.collections4.ArrayStack for testing purposes
+
+package org.apache.commons.collections4;
+
+import java.util.ArrayList;
+
+public class ArrayStack<E> extends ArrayList<E>
+{
+    public ArrayStack(){}
+    public ArrayStack(int p0){}
+    public E peek(){ return null; }
+    public E peek(int p0){ return null; }
+    public E pop(){ return null; }
+    public E push(E p0){ return null; }
+    public boolean empty(){ return false; }
+    public int search(Object p0){ return 0; }
+}

java/ql/test/library-tests/frameworks/apache-collections/test.ql

@@ -0,0 +1,22 @@
+// Generated automatically from org.apache.commons.collections4.Bag for testing purposes
+
+package org.apache.commons.collections4;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+
+public interface Bag<E> extends Collection<E>
+{
+    Iterator<E> iterator();
+    Set<E> uniqueSet();
+    boolean add(E p0);
+    boolean add(E p0, int p1);
+    boolean containsAll(Collection<? extends Object> p0);
+    boolean remove(Object p0);
+    boolean remove(Object p0, int p1);
+    boolean removeAll(Collection<? extends Object> p0);
+    boolean retainAll(Collection<? extends Object> p0);
+    int getCount(Object p0);
+    int size();
+}

java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/ArrayStack.java

@@ -0,0 +1,26 @@
+// Generated automatically from org.apache.commons.collections4.BagUtils for testing purposes
+
+package org.apache.commons.collections4;
+
+import org.apache.commons.collections4.Bag;
+import org.apache.commons.collections4.Predicate;
+import org.apache.commons.collections4.SortedBag;
+import org.apache.commons.collections4.Transformer;
+
+public class BagUtils
+{
+    protected BagUtils() {}
+    public static <E> Bag<E> collectionBag(Bag<E> p0){ return null; }
+    public static <E> Bag<E> emptyBag(){ return null; }
+    public static <E> Bag<E> predicatedBag(Bag<E> p0, Predicate<? super E> p1){ return null; }
+    public static <E> Bag<E> synchronizedBag(Bag<E> p0){ return null; }
+    public static <E> Bag<E> transformingBag(Bag<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
+    public static <E> Bag<E> unmodifiableBag(Bag<? extends E> p0){ return null; }
+    public static <E> SortedBag<E> emptySortedBag(){ return null; }
+    public static <E> SortedBag<E> predicatedSortedBag(SortedBag<E> p0, Predicate<? super E> p1){ return null; }
+    public static <E> SortedBag<E> synchronizedSortedBag(SortedBag<E> p0){ return null; }
+    public static <E> SortedBag<E> transformingSortedBag(SortedBag<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
+    public static <E> SortedBag<E> unmodifiableSortedBag(SortedBag<E> p0){ return null; }
+    public static Bag EMPTY_BAG = null;
+    public static Bag EMPTY_SORTED_BAG = null;
+}

java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/Bag.java

@@ -0,0 +1,15 @@
+// Generated automatically from org.apache.commons.collections4.BidiMap for testing purposes
+
+package org.apache.commons.collections4;
+
+import java.util.Set;
+import org.apache.commons.collections4.IterableMap;
+
+public interface BidiMap<K, V> extends IterableMap<K, V>
+{
+    BidiMap<V, K> inverseBidiMap();
+    K getKey(Object p0);
+    K removeValue(Object p0);
+    Set<V> values();
+    V put(K p0, V p1);
+}

java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/BagUtils.java

@@ -0,0 +1,9 @@
+// Generated automatically from org.apache.commons.collections4.Closure for testing purposes
+
+package org.apache.commons.collections4;
+
+
+public interface Closure<T>
+{
+    void execute(T p0);
+}

java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/BidiMap.java

@@ -0,0 +1,87 @@
+// Generated automatically from org.apache.commons.collections4.CollectionUtils for testing purposes
+
+package org.apache.commons.collections4;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.apache.commons.collections4.Closure;
+import org.apache.commons.collections4.Equator;
+import org.apache.commons.collections4.Predicate;
+import org.apache.commons.collections4.Transformer;
+
+public class CollectionUtils
+{
+    protected CollectionUtils() {}
+    public static <C> Collection<C> predicatedCollection(Collection<C> p0, Predicate<? super C> p1){ return null; }
+    public static <C> Collection<C> retainAll(Collection<C> p0, Collection<? extends Object> p1){ return null; }
+    public static <C> Collection<C> synchronizedCollection(Collection<C> p0){ return null; }
+    public static <C> Collection<C> unmodifiableCollection(Collection<? extends C> p0){ return null; }
+    public static <C> boolean addAll(Collection<C> p0, C... p1){ return false; }
+    public static <C> boolean addAll(Collection<C> p0, Enumeration<? extends C> p1){ return false; }
+    public static <C> boolean addAll(Collection<C> p0, Iterable<? extends C> p1){ return false; }
+    public static <C> boolean addAll(Collection<C> p0, Iterator<? extends C> p1){ return false; }
+    public static <C> boolean exists(Iterable<C> p0, Predicate<? super C> p1){ return false; }
+    public static <C> boolean matchesAll(Iterable<C> p0, Predicate<? super C> p1){ return false; }
+    public static <C> int countMatches(Iterable<C> p0, Predicate<? super C> p1){ return 0; }
+    public static <C> void transform(Collection<C> p0, Transformer<? super C, ? extends C> p1){}
+    public static <E> Collection<E> removeAll(Collection<E> p0, Collection<? extends Object> p1){ return null; }
+    public static <E> Collection<E> removeAll(Iterable<E> p0, Iterable<? extends E> p1, Equator<? super E> p2){ return null; }
+    public static <E> Collection<E> retainAll(Iterable<E> p0, Iterable<? extends E> p1, Equator<? super E> p2){ return null; }
+    public static <E> Collection<E> transformingCollection(Collection<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
+    public static <E> Collection<List<E>> permutations(Collection<E> p0){ return null; }
+    public static <E> E extractSingleton(Collection<E> p0){ return null; }
+    public static <E> boolean isEqualCollection(Collection<? extends E> p0, Collection<? extends E> p1, Equator<? super E> p2){ return false; }
+    public static <I, O, R extends Collection<? super O>> R collect(Iterable<? extends I> p0, Transformer<? super I, ? extends O> p1, R p2){ return null; }
+    public static <I, O, R extends Collection<? super O>> R collect(Iterator<? extends I> p0, Transformer<? super I, ? extends O> p1, R p2){ return null; }
+    public static <I, O> Collection<O> collect(Iterable<I> p0, Transformer<? super I, ? extends O> p1){ return null; }
+    public static <I, O> Collection<O> collect(Iterator<I> p0, Transformer<? super I, ? extends O> p1){ return null; }
+    public static <K, V> Map.Entry<K, V> get(Map<K, V> p0, int p1){ return null; }
+    public static <O extends Comparable<? super O>> List<O> collate(Iterable<? extends O> p0, Iterable<? extends O> p1){ return null; }
+    public static <O extends Comparable<? super O>> List<O> collate(Iterable<? extends O> p0, Iterable<? extends O> p1, boolean p2){ return null; }
+    public static <O, R extends Collection<? super O>> R select(Iterable<? extends O> p0, Predicate<? super O> p1, R p2){ return null; }
+    public static <O, R extends Collection<? super O>> R select(Iterable<? extends O> p0, Predicate<? super O> p1, R p2, R p3){ return null; }
+    public static <O, R extends Collection<? super O>> R selectRejected(Iterable<? extends O> p0, Predicate<? super O> p1, R p2){ return null; }
+    public static <O> Collection<O> disjunction(Iterable<? extends O> p0, Iterable<? extends O> p1){ return null; }
+    public static <O> Collection<O> intersection(Iterable<? extends O> p0, Iterable<? extends O> p1){ return null; }
+    public static <O> Collection<O> select(Iterable<? extends O> p0, Predicate<? super O> p1){ return null; }
+    public static <O> Collection<O> selectRejected(Iterable<? extends O> p0, Predicate<? super O> p1){ return null; }
+    public static <O> Collection<O> subtract(Iterable<? extends O> p0, Iterable<? extends O> p1){ return null; }
+    public static <O> Collection<O> subtract(Iterable<? extends O> p0, Iterable<? extends O> p1, Predicate<O> p2){ return null; }
+    public static <O> Collection<O> union(Iterable<? extends O> p0, Iterable<? extends O> p1){ return null; }
+    public static <O> List<O> collate(Iterable<? extends O> p0, Iterable<? extends O> p1, Comparator<? super O> p2){ return null; }
+    public static <O> List<O> collate(Iterable<? extends O> p0, Iterable<? extends O> p1, Comparator<? super O> p2, boolean p3){ return null; }
+    public static <O> Map<O, Integer> getCardinalityMap(Iterable<? extends O> p0){ return null; }
+    public static <O> int cardinality(O p0, Iterable<? super O> p1){ return 0; }
+    public static <T, C extends Closure<? super T>> C forAllDo(Iterable<T> p0, C p1){ return null; }
+    public static <T, C extends Closure<? super T>> C forAllDo(Iterator<T> p0, C p1){ return null; }
+    public static <T, C extends Closure<? super T>> T forAllButLastDo(Iterable<T> p0, C p1){ return null; }
+    public static <T, C extends Closure<? super T>> T forAllButLastDo(Iterator<T> p0, C p1){ return null; }
+    public static <T> Collection<T> emptyCollection(){ return null; }
+    public static <T> Collection<T> emptyIfNull(Collection<T> p0){ return null; }
+    public static <T> T find(Iterable<T> p0, Predicate<? super T> p1){ return null; }
+    public static <T> T get(Iterable<T> p0, int p1){ return null; }
+    public static <T> T get(Iterator<T> p0, int p1){ return null; }
+    public static <T> boolean addIgnoreNull(Collection<T> p0, T p1){ return false; }
+    public static <T> boolean containsAny(Collection<? extends Object> p0, T... p1){ return false; }
+    public static <T> boolean filter(Iterable<T> p0, Predicate<? super T> p1){ return false; }
+    public static <T> boolean filterInverse(Iterable<T> p0, Predicate<? super T> p1){ return false; }
+    public static Collection EMPTY_COLLECTION = null;
+    public static Object get(Object p0, int p1){ return null; }
+    public static boolean containsAll(Collection<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static boolean containsAny(Collection<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static boolean isEmpty(Collection<? extends Object> p0){ return false; }
+    public static boolean isEqualCollection(Collection<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static boolean isFull(Collection<? extends Object> p0){ return false; }
+    public static boolean isNotEmpty(Collection<? extends Object> p0){ return false; }
+    public static boolean isProperSubCollection(Collection<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static boolean isSubCollection(Collection<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static boolean sizeIsEmpty(Object p0){ return false; }
+    public static int maxSize(Collection<? extends Object> p0){ return 0; }
+    public static int size(Object p0){ return 0; }
+    public static void reverseArray(Object[] p0){}
+    static void checkIndexBounds(int p0){}
+}