Generate stubs.

Some generated stubs were manually adjusted due to minor issues in the stub generator.
In particular, ambiguous references were resolved and references to private classes were removed.

java/ql/test/library-tests/frameworks/guava/generated/Test.java

@@ -40,7 +40,7 @@ import com.google.common.collect.Multimaps;
 import com.google.common.collect.Multiset;
 import com.google.common.collect.Multisets;
 import com.google.common.collect.MutableClassToInstanceMap;
-import com.google.common.collect.ObjectArrays;
+//import com.google.common.collect.ObjectArrays;
 import com.google.common.collect.PeekingIterator;
 import com.google.common.collect.Queues;
 import com.google.common.collect.RowSortedTable;

java/ql/test/library-tests/frameworks/guava/generated/options

@@ -0,0 +1 @@
+//semmle-extractor-options: --javac-args -cp ${testdir}/../../../../stubs/guava-30.0

java/ql/test/stubs/guava-30.0/com/google/common/base/Converter.java

@@ -1,55 +1,24 @@
-/*
- * Copyright (C) 2008 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- * in compliance with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
- */
+// Generated automatically from com.google.common.base.Converter for testing purposes
 
 package com.google.common.base;
-import org.checkerframework.checker.nullness.qual.Nullable;
 
-public abstract class Converter<A, B> implements Function<A, B> {
-  public final @Nullable B convert(@Nullable A a) {
-    return null;
-  }
-
-  public Iterable<B> convertAll(final Iterable<? extends A> fromIterable) {
-    return null;
-  }
-
-  public Converter<B, A> reverse() {
-    return null;
-  }
-
-  public final <C> Converter<A, C> andThen(Converter<B, C> secondConverter) {
-    return null;
-  }
-
-  @Override
-  public final @Nullable B apply(@Nullable A a) {
-    return null;
-  }
-
-  @Override
-  public boolean equals(@Nullable Object object) {
-    return false;
-  }
-
-  public static <A, B> Converter<A, B> from(
-      Function<? super A, ? extends B> forwardFunction,
-      Function<? super B, ? extends A> backwardFunction) {
-    return null;
-  }
-
-  public static <T> Converter<T, T> identity() {
-    return null;
-  }
+import com.google.common.base.Function;
 
+abstract public class Converter<A, B> implements Function<A, B>
+{
+    <C> Converter<A, C> doAndThen(Converter<B, C> p0){ return null; }
+    A correctedDoBackward(B p0){ return null; }
+    B correctedDoForward(A p0){ return null; }
+    Converter(boolean p0){}
+    protected Converter(){}
+    protected abstract A doBackward(B p0);
+    protected abstract B doForward(A p0);
+    public Converter<B, A> reverse(){ return null; }
+    public Iterable<B> convertAll(Iterable<? extends A> p0){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public final <C> Converter<A, C> andThen(Converter<B, C> p0){ return null; }
+    public final B apply(A p0){ return null; }
+    public final B convert(A p0){ return null; }
+    public static <A, B> Converter<A, B> from(Function<? super A, ? extends B> p0, Function<? super B, ? extends A> p1){ return null; }
+    public static <T> Converter<T, T> identity(){ return null; }
 }

java/ql/test/stubs/guava-30.0/com/google/common/base/Equivalence.java

@@ -0,0 +1,32 @@
+// Generated automatically from com.google.common.base.Equivalence for testing purposes
+
+package com.google.common.base;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import java.io.Serializable;
+import java.util.function.BiPredicate;
+
+abstract public class Equivalence<T> implements BiPredicate<T, T>
+{
+    protected Equivalence(){}
+    protected abstract boolean doEquivalent(T p0, T p1);
+    protected abstract int doHash(T p0);
+    public final <F> Equivalence<F> onResultOf(Function<F, ? extends T> p0){ return null; }
+    public final <S extends T> Equivalence.Wrapper<S> wrap(S p0){ return null; }
+    public final <S extends T> Equivalence<Iterable<S>> pairwise(){ return null; }
+    public final Predicate<T> equivalentTo(T p0){ return null; }
+    public final boolean equivalent(T p0, T p1){ return false; }
+    public final boolean test(T p0, T p1){ return false; }
+    public final int hash(T p0){ return 0; }
+    public static Equivalence<Object> equals(){ return null; }
+    public static Equivalence<Object> identity(){ return null; }
+    static public class Wrapper<T> implements Serializable
+    {
+        protected Wrapper() {}
+        public String toString(){ return null; }
+        public T get(){ return null; }
+        public boolean equals(Object p0){ return false; }
+        public int hashCode(){ return 0; }
+    }
+}

java/ql/test/stubs/guava-30.0/com/google/common/base/Optional.java

@@ -1,77 +1,31 @@
-/*
- * Copyright (C) 2011 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- * in compliance with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
- */
+// Generated automatically from com.google.common.base.Optional for testing purposes, and manually adjusted.
 
 package com.google.common.base;
+
+import com.google.common.base.Function;
+import com.google.common.base.Supplier;
 import java.io.Serializable;
 import java.util.Set;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-public abstract class Optional<T> implements Serializable {
-  public static <T> Optional<T> absent() {
-    return null;
-  }
-
-  public static <T> Optional<T> of(T reference) {
-    return null;
-  }
-
-  public static <T> Optional<T> fromNullable(@Nullable T nullableReference) {
-    return null;
-  }
-
-  public static <T> @Nullable Optional<T> fromJavaUtil(
-      java.util.@Nullable Optional<T> javaUtilOptional) {
-    return null;
-  }
-
-  public static <T> java.util.@Nullable Optional<T> toJavaUtil(
-      @Nullable Optional<T> googleOptional) {
-    return null;
-  }
-
-  public java.util.Optional<T> toJavaUtil() {
-    return null;
-  }
-
-  public abstract boolean isPresent();
-
-  public abstract T get();
-
-  public abstract T or(T defaultValue);
-
-  public abstract Optional<T> or(Optional<? extends T> secondChoice);
-
-  public abstract T or(Supplier<? extends T> supplier);
-
-  public abstract @Nullable T orNull();
-
-  public abstract Set<T> asSet();
-
-  public abstract <V> Optional<V> transform(Function<? super T, V> function);
-
-  @Override
-  public abstract boolean equals(@Nullable Object object);
-
-  @Override
-  public abstract int hashCode();
-
-  @Override
-  public abstract String toString();
-
-  public static <T> Iterable<T> presentInstances(
-      final Iterable<? extends Optional<? extends T>> optionals) {
-    return null;
-  }
 
+abstract public class Optional<T> implements Serializable
+{
+    Optional(){}
+    public java.util.Optional<T> toJavaUtil(){ return null; }
+    public abstract <V> Optional<V> transform(Function<? super T, V> p0);
+    public abstract Optional<T> or(Optional<? extends T> p0);
+    public abstract Set<T> asSet();
+    public abstract String toString();
+    public abstract T get();
+    public abstract T or(Supplier<? extends T> p0);
+    public abstract T or(T p0);
+    public abstract T orNull();
+    public abstract boolean equals(Object p0);
+    public abstract boolean isPresent();
+    public abstract int hashCode();
+    public static <T> Iterable<T> presentInstances(Iterable<? extends Optional<? extends T>> p0){ return null; }
+    public static <T> Optional<T> absent(){ return null; }
+    public static <T> Optional<T> fromJavaUtil(java.util.Optional<T> p0){ return null; }
+    public static <T> Optional<T> fromNullable(T p0){ return null; }
+    public static <T> Optional<T> of(T p0){ return null; }
+    public static <T> java.util.Optional<T> toJavaUtil(Optional<T> p0){ return null; }
 }

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractListMultimap.java

@@ -0,0 +1,25 @@
+// Generated automatically from com.google.common.collect.AbstractListMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMapBasedMultimap;
+import com.google.common.collect.ListMultimap;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+abstract class AbstractListMultimap<K, V> extends AbstractMapBasedMultimap<K, V> implements ListMultimap<K, V>
+{
+    protected AbstractListMultimap() {}
+    <E> Collection<E> unmodifiableCollectionSubclass(Collection<E> p0){ return null; }
+    Collection<V> wrapCollection(K p0, Collection<V> p1){ return null; }
+    List<V> createUnmodifiableEmptyCollection(){ return null; }
+    abstract List<V> createCollection();
+    protected AbstractListMultimap(Map<K, Collection<V>> p0){}
+    public List<V> get(K p0){ return null; }
+    public List<V> removeAll(Object p0){ return null; }
+    public List<V> replaceValues(K p0, Iterable<? extends V> p1){ return null; }
+    public Map<K, Collection<V>> asMap(){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public boolean put(K p0, V p1){ return false; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractMapBasedMultimap.java

@@ -0,0 +1,79 @@
+// Generated automatically from com.google.common.collect.AbstractMapBasedMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMultimap;
+import com.google.common.collect.Multiset;
+import java.io.Serializable;
+import java.util.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.BiConsumer;
+
+abstract class AbstractMapBasedMultimap<K, V> extends AbstractMultimap<K, V> implements Serializable
+{
+    protected AbstractMapBasedMultimap() {}
+    <E> Collection<E> unmodifiableCollectionSubclass(Collection<E> p0){ return null; }
+    Collection<Map.Entry<K, V>> createEntries(){ return null; }
+    Collection<V> createCollection(K p0){ return null; }
+    Collection<V> createUnmodifiableEmptyCollection(){ return null; }
+    Collection<V> createValues(){ return null; }
+    Collection<V> wrapCollection(K p0, Collection<V> p1){ return null; }
+    Iterator<Map.Entry<K, V>> entryIterator(){ return null; }
+    Iterator<V> valueIterator(){ return null; }
+    Map<K, Collection<V>> backingMap(){ return null; }
+    Map<K, Collection<V>> createAsMap(){ return null; }
+    Multiset<K> createKeys(){ return null; }
+    Set<K> createKeySet(){ return null; }
+    Spliterator<Map.Entry<K, V>> entrySpliterator(){ return null; }
+    Spliterator<V> valueSpliterator(){ return null; }
+    abstract Collection<V> createCollection();
+    class WrappedCollection extends AbstractCollection<V>
+    {
+        protected WrappedCollection() {}
+        AbstractMapBasedMultimap.WrappedCollection getAncestor(){ return null; }
+        Collection<V> delegate = null;
+        Collection<V> getDelegate(){ return null; }
+        K getKey(){ return null; }
+        WrappedCollection(K p0, Collection<V> p1, AbstractMapBasedMultimap.WrappedCollection p2){}
+        final AbstractMapBasedMultimap.WrappedCollection ancestor = null;
+        final Collection<V> ancestorDelegate = null;
+        final K key = null;
+        public Iterator<V> iterator(){ return null; }
+        public Spliterator<V> spliterator(){ return null; }
+        public String toString(){ return null; }
+        public boolean add(V p0){ return false; }
+        public boolean addAll(Collection<? extends V> p0){ return false; }
+        public boolean contains(Object p0){ return false; }
+        public boolean containsAll(Collection<? extends Object> p0){ return false; }
+        public boolean equals(Object p0){ return false; }
+        public boolean remove(Object p0){ return false; }
+        public boolean removeAll(Collection<? extends Object> p0){ return false; }
+        public boolean retainAll(Collection<? extends Object> p0){ return false; }
+        public int hashCode(){ return 0; }
+        public int size(){ return 0; }
+        public void clear(){}
+        void addToMap(){}
+        void refreshIfEmpty(){}
+        void removeIfEmpty(){}
+    }
+    final List<V> wrapList(K p0, List<V> p1, AbstractMapBasedMultimap.WrappedCollection p2){ return null; }
+    final Map<K, Collection<V>> createMaybeNavigableAsMap(){ return null; }
+    final Set<K> createMaybeNavigableKeySet(){ return null; }
+    final void setMap(Map<K, Collection<V>> p0){}
+    protected AbstractMapBasedMultimap(Map<K, Collection<V>> p0){}
+    public Collection<Map.Entry<K, V>> entries(){ return null; }
+    public Collection<V> get(K p0){ return null; }
+    public Collection<V> removeAll(Object p0){ return null; }
+    public Collection<V> replaceValues(K p0, Iterable<? extends V> p1){ return null; }
+    public Collection<V> values(){ return null; }
+    public boolean containsKey(Object p0){ return false; }
+    public boolean put(K p0, V p1){ return false; }
+    public int size(){ return 0; }
+    public void clear(){}
+    public void forEach(BiConsumer<? super K, ? super V> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractMapBasedMultiset.java

@@ -0,0 +1,31 @@
+// Generated automatically from com.google.common.collect.AbstractMapBasedMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMultiset;
+import com.google.common.collect.Count;
+import com.google.common.collect.Multiset;
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.ObjIntConsumer;
+
+abstract class AbstractMapBasedMultiset<E> extends AbstractMultiset<E> implements Serializable
+{
+    protected AbstractMapBasedMultiset() {}
+    Iterator<E> elementIterator(){ return null; }
+    Iterator<Multiset.Entry<E>> entryIterator(){ return null; }
+    int distinctElements(){ return 0; }
+    protected AbstractMapBasedMultiset(Map<E, Count> p0){}
+    public Iterator<E> iterator(){ return null; }
+    public Set<Multiset.Entry<E>> entrySet(){ return null; }
+    public int add(E p0, int p1){ return 0; }
+    public int count(Object p0){ return 0; }
+    public int remove(Object p0, int p1){ return 0; }
+    public int setCount(E p0, int p1){ return 0; }
+    public int size(){ return 0; }
+    public void clear(){}
+    public void forEachEntry(ObjIntConsumer<? super E> p0){}
+    void setBackingMap(Map<E, Count> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractMultimap.java

@@ -5,6 +5,7 @@ package com.google.common.collect;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multiset;
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractMultiset.java

@@ -0,0 +1,36 @@
+// Generated automatically from com.google.common.collect.AbstractMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.Multiset;
+import java.util.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+
+abstract class AbstractMultiset<E> extends AbstractCollection<E> implements Multiset<E>
+{
+    AbstractMultiset(){}
+    Set<E> createElementSet(){ return null; }
+    Set<Multiset.Entry<E>> createEntrySet(){ return null; }
+    abstract Iterator<E> elementIterator();
+    abstract Iterator<Multiset.Entry<E>> entryIterator();
+    abstract int distinctElements();
+    public Set<E> elementSet(){ return null; }
+    public Set<Multiset.Entry<E>> entrySet(){ return null; }
+    public abstract void clear();
+    public boolean contains(Object p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public boolean setCount(E p0, int p1, int p2){ return false; }
+    public final String toString(){ return null; }
+    public final boolean add(E p0){ return false; }
+    public final boolean addAll(Collection<? extends E> p0){ return false; }
+    public final boolean equals(Object p0){ return false; }
+    public final boolean remove(Object p0){ return false; }
+    public final boolean removeAll(Collection<? extends Object> p0){ return false; }
+    public final boolean retainAll(Collection<? extends Object> p0){ return false; }
+    public final int hashCode(){ return 0; }
+    public int add(E p0, int p1){ return 0; }
+    public int remove(Object p0, int p1){ return 0; }
+    public int setCount(E p0, int p1){ return 0; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractSetMultimap.java

@@ -0,0 +1,26 @@
+// Generated automatically from com.google.common.collect.AbstractSetMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMapBasedMultimap;
+import com.google.common.collect.SetMultimap;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+abstract class AbstractSetMultimap<K, V> extends AbstractMapBasedMultimap<K, V> implements SetMultimap<K, V>
+{
+    protected AbstractSetMultimap() {}
+    <E> Collection<E> unmodifiableCollectionSubclass(Collection<E> p0){ return null; }
+    Collection<V> wrapCollection(K p0, Collection<V> p1){ return null; }
+    Set<V> createUnmodifiableEmptyCollection(){ return null; }
+    abstract Set<V> createCollection();
+    protected AbstractSetMultimap(Map<K, Collection<V>> p0){}
+    public Map<K, Collection<V>> asMap(){ return null; }
+    public Set<Map.Entry<K, V>> entries(){ return null; }
+    public Set<V> get(K p0){ return null; }
+    public Set<V> removeAll(Object p0){ return null; }
+    public Set<V> replaceValues(K p0, Iterable<? extends V> p1){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public boolean put(K p0, V p1){ return false; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractSortedKeySortedSetMultimap.java

@@ -0,0 +1,19 @@
+// Generated automatically from com.google.common.collect.AbstractSortedKeySortedSetMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractSortedSetMultimap;
+import java.util.Collection;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+
+abstract class AbstractSortedKeySortedSetMultimap<K, V> extends AbstractSortedSetMultimap<K, V>
+{
+    protected AbstractSortedKeySortedSetMultimap() {}
+    AbstractSortedKeySortedSetMultimap(SortedMap<K, Collection<V>> p0){}
+    Set<K> createKeySet(){ return null; }
+    SortedMap<K, Collection<V>> backingMap(){ return null; }
+    public SortedMap<K, Collection<V>> asMap(){ return null; }
+    public SortedSet<K> keySet(){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractSortedMultiset.java

@@ -0,0 +1,30 @@
+// Generated automatically from com.google.common.collect.AbstractSortedMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMultiset;
+import com.google.common.collect.BoundType;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.SortedMultiset;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.NavigableSet;
+
+abstract class AbstractSortedMultiset<E> extends AbstractMultiset<E> implements SortedMultiset<E>
+{
+    AbstractSortedMultiset(){}
+    AbstractSortedMultiset(Comparator<? super E> p0){}
+    Iterator<E> descendingIterator(){ return null; }
+    NavigableSet<E> createElementSet(){ return null; }
+    SortedMultiset<E> createDescendingMultiset(){ return null; }
+    abstract Iterator<Multiset.Entry<E>> descendingEntryIterator();
+    final Comparator<? super E> comparator = null;
+    public Comparator<? super E> comparator(){ return null; }
+    public Multiset.Entry<E> firstEntry(){ return null; }
+    public Multiset.Entry<E> lastEntry(){ return null; }
+    public Multiset.Entry<E> pollFirstEntry(){ return null; }
+    public Multiset.Entry<E> pollLastEntry(){ return null; }
+    public NavigableSet<E> elementSet(){ return null; }
+    public SortedMultiset<E> descendingMultiset(){ return null; }
+    public SortedMultiset<E> subMultiset(E p0, BoundType p1, E p2, BoundType p3){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractSortedSetMultimap.java

@@ -0,0 +1,24 @@
+// Generated automatically from com.google.common.collect.AbstractSortedSetMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractSetMultimap;
+import com.google.common.collect.SortedSetMultimap;
+import java.util.Collection;
+import java.util.Map;
+import java.util.SortedSet;
+
+abstract class AbstractSortedSetMultimap<K, V> extends AbstractSetMultimap<K, V> implements SortedSetMultimap<K, V>
+{
+    protected AbstractSortedSetMultimap() {}
+    <E> SortedSet<E> unmodifiableCollectionSubclass(Collection<E> p0){ return null; }
+    Collection<V> wrapCollection(K p0, Collection<V> p1){ return null; }
+    SortedSet<V> createUnmodifiableEmptyCollection(){ return null; }
+    abstract SortedSet<V> createCollection();
+    protected AbstractSortedSetMultimap(Map<K, Collection<V>> p0){}
+    public Collection<V> values(){ return null; }
+    public Map<K, Collection<V>> asMap(){ return null; }
+    public SortedSet<V> get(K p0){ return null; }
+    public SortedSet<V> removeAll(Object p0){ return null; }
+    public SortedSet<V> replaceValues(K p0, Iterable<? extends V> p1){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/AbstractTable.java

@@ -1,90 +1,37 @@
-/*
- * Copyright (C) 2013 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- * in compliance with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
- */
+// Generated automatically from com.google.common.collect.AbstractTable for testing purposes
 
 package com.google.common.collect;
 
+import com.google.common.collect.Table;
 import java.util.Collection;
-import java.util.Map;
+import java.util.Iterator;
 import java.util.Set;
+import java.util.Spliterator;
 
-abstract class AbstractTable<R, C, V> implements Table<R, C, V> {
-  @Override
-  public boolean containsRow(Object rowKey) {
-    return false;
-  }
-
-  @Override
-  public boolean containsColumn(Object columnKey) {
-    return false;
-  }
-
-  @Override
-  public Set<R> rowKeySet() {
-    return null;
-  }
-
-  @Override
-  public Set<C> columnKeySet() {
-    return null;
-  }
-
-  @Override
-  public boolean containsValue(Object value) {
-    return false;
-  }
-
-  @Override
-  public boolean contains(Object rowKey, Object columnKey) {
-    return false;
-  }
-
-  @Override
-  public V get(Object rowKey, Object columnKey) {
-    return null;
-  }
-
-  @Override
-  public boolean isEmpty() {
-    return false;
-  }
-
-  @Override
-  public void clear() {
-  }
-
-  @Override
-  public V remove(Object rowKey, Object columnKey) {
-    return null;
-  }
-
-  @Override
-  public V put(R rowKey, C columnKey, V value) {
-    return null;
-  }
-
-  @Override
-  public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
-  }
-
-  @Override
-  public Set<Cell<R, C, V>> cellSet() {
-    return null;
-  }
-
-  @Override
-  public Collection<V> values() {
-    return null;
-  }
-
+abstract class AbstractTable<R, C, V> implements Table<R, C, V>
+{
+    AbstractTable(){}
+    Collection<V> createValues(){ return null; }
+    Iterator<V> valuesIterator(){ return null; }
+    Set<Table.Cell<R, C, V>> createCellSet(){ return null; }
+    Spliterator<V> valuesSpliterator(){ return null; }
+    abstract Iterator<Table.Cell<R, C, V>> cellIterator();
+    abstract Spliterator<Table.Cell<R, C, V>> cellSpliterator();
+    public Collection<V> values(){ return null; }
+    public Set<C> columnKeySet(){ return null; }
+    public Set<R> rowKeySet(){ return null; }
+    public Set<Table.Cell<R, C, V>> cellSet(){ return null; }
+    public String toString(){ return null; }
+    public V get(Object p0, Object p1){ return null; }
+    public V put(R p0, C p1, V p2){ return null; }
+    public V remove(Object p0, Object p1){ return null; }
+    public boolean contains(Object p0, Object p1){ return false; }
+    public boolean containsColumn(Object p0){ return false; }
+    public boolean containsRow(Object p0){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public boolean equals(Object p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public int hashCode(){ return 0; }
+    public void clear(){}
+    public void putAll(Table<? extends R, ? extends C, ? extends V> p0){}
 }

java/ql/test/stubs/guava-30.0/com/google/common/collect/ArrayListMultimap.java

@@ -0,0 +1,18 @@
+// Generated automatically from com.google.common.collect.ArrayListMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ArrayListMultimapGwtSerializationDependencies;
+import com.google.common.collect.Multimap;
+import java.util.List;
+
+public class ArrayListMultimap<K, V> extends ArrayListMultimapGwtSerializationDependencies<K, V>
+{
+    protected ArrayListMultimap() {}
+    List<V> createCollection(){ return null; }
+    int expectedValuesPerKey = 0;
+    public static <K, V> ArrayListMultimap<K, V> create(){ return null; }
+    public static <K, V> ArrayListMultimap<K, V> create(Multimap<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> ArrayListMultimap<K, V> create(int p0, int p1){ return null; }
+    public void trimToSize(){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ArrayListMultimapGwtSerializationDependencies.java

@@ -0,0 +1,13 @@
+// Generated automatically from com.google.common.collect.ArrayListMultimapGwtSerializationDependencies for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractListMultimap;
+import java.util.Collection;
+import java.util.Map;
+
+abstract class ArrayListMultimapGwtSerializationDependencies<K, V> extends AbstractListMultimap<K, V>
+{
+    protected ArrayListMultimapGwtSerializationDependencies() {}
+    ArrayListMultimapGwtSerializationDependencies(Map<K, Collection<V>> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ArrayTable.java

@@ -0,0 +1,51 @@
+// Generated automatically from com.google.common.collect.ArrayTable for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractTable;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Table;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Spliterator;
+
+public class ArrayTable<R, C, V> extends AbstractTable<R, C, V> implements Serializable
+{
+    protected ArrayTable() {}
+    Iterator<Table.Cell<R, C, V>> cellIterator(){ return null; }
+    Iterator<V> valuesIterator(){ return null; }
+    Spliterator<Table.Cell<R, C, V>> cellSpliterator(){ return null; }
+    Spliterator<V> valuesSpliterator(){ return null; }
+    public Collection<V> values(){ return null; }
+    public ImmutableList<C> columnKeyList(){ return null; }
+    public ImmutableList<R> rowKeyList(){ return null; }
+    public ImmutableSet<C> columnKeySet(){ return null; }
+    public ImmutableSet<R> rowKeySet(){ return null; }
+    public Map<C, Map<R, V>> columnMap(){ return null; }
+    public Map<C, V> row(R p0){ return null; }
+    public Map<R, Map<C, V>> rowMap(){ return null; }
+    public Map<R, V> column(C p0){ return null; }
+    public Set<Table.Cell<R, C, V>> cellSet(){ return null; }
+    public V at(int p0, int p1){ return null; }
+    public V erase(Object p0, Object p1){ return null; }
+    public V get(Object p0, Object p1){ return null; }
+    public V put(R p0, C p1, V p2){ return null; }
+    public V remove(Object p0, Object p1){ return null; }
+    public V set(int p0, int p1, V p2){ return null; }
+    public V[] toArray(Class<V> p0){ return null; }
+    public boolean contains(Object p0, Object p1){ return false; }
+    public boolean containsColumn(Object p0){ return false; }
+    public boolean containsRow(Object p0){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public int size(){ return 0; }
+    public static <R, C, V> ArrayTable<R, C, V> create(Iterable<? extends R> p0, Iterable<? extends C> p1){ return null; }
+    public static <R, C, V> ArrayTable<R, C, V> create(Table<R, C, V> p0){ return null; }
+    public void clear(){}
+    public void eraseAll(){}
+    public void putAll(Table<? extends R, ? extends C, ? extends V> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/BiMap.java

@@ -0,0 +1,15 @@
+// Generated automatically from com.google.common.collect.BiMap for testing purposes
+
+package com.google.common.collect;
+
+import java.util.Map;
+import java.util.Set;
+
+public interface BiMap<K, V> extends Map<K, V>
+{
+    BiMap<V, K> inverse();
+    Set<V> values();
+    V forcePut(K p0, V p1);
+    V put(K p0, V p1);
+    void putAll(Map<? extends K, ? extends V> p0);
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/BoundType.java

@@ -0,0 +1,13 @@
+// Generated automatically from com.google.common.collect.BoundType for testing purposes
+
+package com.google.common.collect;
+
+
+public enum BoundType
+{
+    CLOSED, OPEN;
+    private BoundType() {}
+    BoundType flip(){ return null; }
+    final boolean inclusive = false;
+    static BoundType forBoolean(boolean p0){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ClassToInstanceMap.java

@@ -0,0 +1,11 @@
+// Generated automatically from com.google.common.collect.ClassToInstanceMap for testing purposes
+
+package com.google.common.collect;
+
+import java.util.Map;
+
+public interface ClassToInstanceMap<B> extends Map<Class<? extends B>, B>
+{
+    <T extends B> T getInstance(Class<T> p0);
+    <T extends B> T putInstance(Class<T> p0, T p1);
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Collections2.java

@@ -0,0 +1,24 @@
+// Generated automatically from com.google.common.collect.Collections2 for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+
+public class Collections2
+{
+    protected Collections2() {}
+    public static <E extends Comparable<? super E>> Collection<List<E>> orderedPermutations(Iterable<E> p0){ return null; }
+    public static <E> Collection<E> filter(Collection<E> p0, Predicate<? super E> p1){ return null; }
+    public static <E> Collection<List<E>> orderedPermutations(Iterable<E> p0, Comparator<? super E> p1){ return null; }
+    public static <E> Collection<List<E>> permutations(Collection<E> p0){ return null; }
+    public static <F, T> Collection<T> transform(Collection<F> p0, Function<? super F, T> p1){ return null; }
+    static String toStringImpl(Collection<? extends Object> p0){ return null; }
+    static StringBuilder newStringBuilderForCollection(int p0){ return null; }
+    static boolean containsAllImpl(Collection<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    static boolean safeContains(Collection<? extends Object> p0, Object p1){ return false; }
+    static boolean safeRemove(Collection<? extends Object> p0, Object p1){ return false; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ConcurrentHashMultiset.java

@@ -0,0 +1,37 @@
+// Generated automatically from com.google.common.collect.ConcurrentHashMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMultiset;
+import com.google.common.collect.Multiset;
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ConcurrentHashMultiset<E> extends AbstractMultiset<E> implements Serializable
+{
+    protected ConcurrentHashMultiset() {}
+    ConcurrentHashMultiset(ConcurrentMap<E, AtomicInteger> p0){}
+    Iterator<E> elementIterator(){ return null; }
+    Iterator<Multiset.Entry<E>> entryIterator(){ return null; }
+    Set<E> createElementSet(){ return null; }
+    int distinctElements(){ return 0; }
+    public <T> T[] toArray(T[] p0){ return null; }
+    public Iterator<E> iterator(){ return null; }
+    public Object[] toArray(){ return null; }
+    public Set<Multiset.Entry<E>> createEntrySet(){ return null; }
+    public boolean isEmpty(){ return false; }
+    public boolean removeExactly(Object p0, int p1){ return false; }
+    public boolean setCount(E p0, int p1, int p2){ return false; }
+    public int add(E p0, int p1){ return 0; }
+    public int count(Object p0){ return 0; }
+    public int remove(Object p0, int p1){ return 0; }
+    public int setCount(E p0, int p1){ return 0; }
+    public int size(){ return 0; }
+    public static <E> ConcurrentHashMultiset<E> create(){ return null; }
+    public static <E> ConcurrentHashMultiset<E> create(ConcurrentMap<E, AtomicInteger> p0){ return null; }
+    public static <E> ConcurrentHashMultiset<E> create(Iterable<? extends E> p0){ return null; }
+    public void clear(){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Count.java

@@ -0,0 +1,19 @@
+// Generated automatically from com.google.common.collect.Count for testing purposes
+
+package com.google.common.collect;
+
+import java.io.Serializable;
+
+class Count implements Serializable
+{
+    protected Count() {}
+    Count(int p0){}
+    public String toString(){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public int addAndGet(int p0){ return 0; }
+    public int get(){ return 0; }
+    public int getAndSet(int p0){ return 0; }
+    public int hashCode(){ return 0; }
+    public void add(int p0){}
+    public void set(int p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Cut.java

@@ -0,0 +1,32 @@
+// Generated automatically from com.google.common.collect.Cut for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.BoundType;
+import com.google.common.collect.DiscreteDomain;
+import java.io.Serializable;
+
+abstract class Cut<C extends Comparable> implements Comparable<Cut<C>>, Serializable
+{
+    protected Cut() {}
+    C endpoint(){ return null; }
+    Cut(C p0){}
+    Cut<C> canonical(DiscreteDomain<C> p0){ return null; }
+    abstract BoundType typeAsLowerBound();
+    abstract BoundType typeAsUpperBound();
+    abstract C greatestValueBelow(DiscreteDomain<C> p0);
+    abstract C leastValueAbove(DiscreteDomain<C> p0);
+    abstract Cut<C> withLowerBoundType(BoundType p0, DiscreteDomain<C> p1);
+    abstract Cut<C> withUpperBoundType(BoundType p0, DiscreteDomain<C> p1);
+    abstract boolean isLessThan(C p0);
+    abstract void describeAsLowerBound(StringBuilder p0);
+    abstract void describeAsUpperBound(StringBuilder p0);
+    final C endpoint = null;
+    public abstract int hashCode();
+    public boolean equals(Object p0){ return false; }
+    public int compareTo(Cut<C> p0){ return 0; }
+    static <C extends Comparable> Cut<C> aboveAll(){ return null; }
+    static <C extends Comparable> Cut<C> aboveValue(C p0){ return null; }
+    static <C extends Comparable> Cut<C> belowAll(){ return null; }
+    static <C extends Comparable> Cut<C> belowValue(C p0){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/DiscreteDomain.java

@@ -0,0 +1,20 @@
+// Generated automatically from com.google.common.collect.DiscreteDomain for testing purposes
+
+package com.google.common.collect;
+
+import java.math.BigInteger;
+
+abstract public class DiscreteDomain<C extends Comparable>
+{
+    C offset(C p0, long p1){ return null; }
+    final boolean supportsFastOffset = false;
+    protected DiscreteDomain(){}
+    public C maxValue(){ return null; }
+    public C minValue(){ return null; }
+    public abstract C next(C p0);
+    public abstract C previous(C p0);
+    public abstract long distance(C p0, C p1);
+    public static DiscreteDomain<BigInteger> bigIntegers(){ return null; }
+    public static DiscreteDomain<Integer> integers(){ return null; }
+    public static DiscreteDomain<Long> longs(){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ForwardingMap.java

@@ -0,0 +1,37 @@
+// Generated automatically from com.google.common.collect.ForwardingMap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ForwardingObject;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+abstract public class ForwardingMap<K, V> extends ForwardingObject implements Map<K, V>
+{
+    protected ForwardingMap(){}
+    protected String standardToString(){ return null; }
+    protected V standardRemove(Object p0){ return null; }
+    protected abstract Map<K, V> delegate();
+    protected boolean standardContainsKey(Object p0){ return false; }
+    protected boolean standardContainsValue(Object p0){ return false; }
+    protected boolean standardEquals(Object p0){ return false; }
+    protected boolean standardIsEmpty(){ return false; }
+    protected int standardHashCode(){ return 0; }
+    protected void standardClear(){}
+    protected void standardPutAll(Map<? extends K, ? extends V> p0){}
+    public Collection<V> values(){ return null; }
+    public Set<K> keySet(){ return null; }
+    public Set<Map.Entry<K, V>> entrySet(){ return null; }
+    public V get(Object p0){ return null; }
+    public V put(K p0, V p1){ return null; }
+    public V remove(Object p0){ return null; }
+    public boolean containsKey(Object p0){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public boolean equals(Object p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public int hashCode(){ return 0; }
+    public int size(){ return 0; }
+    public void clear(){}
+    public void putAll(Map<? extends K, ? extends V> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ForwardingObject.java

@@ -0,0 +1,11 @@
+// Generated automatically from com.google.common.collect.ForwardingObject for testing purposes
+
+package com.google.common.collect;
+
+
+abstract public class ForwardingObject
+{
+    protected ForwardingObject(){}
+    protected abstract Object delegate();
+    public String toString(){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/GeneralRange.java

@@ -0,0 +1,34 @@
+// Generated automatically from com.google.common.collect.GeneralRange for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.BoundType;
+import com.google.common.collect.Range;
+import java.io.Serializable;
+import java.util.Comparator;
+
+class GeneralRange<T> implements Serializable
+{
+    protected GeneralRange() {}
+    BoundType getLowerBoundType(){ return null; }
+    BoundType getUpperBoundType(){ return null; }
+    Comparator<? super T> comparator(){ return null; }
+    GeneralRange<T> intersect(GeneralRange<T> p0){ return null; }
+    GeneralRange<T> reverse(){ return null; }
+    T getLowerEndpoint(){ return null; }
+    T getUpperEndpoint(){ return null; }
+    boolean contains(T p0){ return false; }
+    boolean hasLowerBound(){ return false; }
+    boolean hasUpperBound(){ return false; }
+    boolean isEmpty(){ return false; }
+    boolean tooHigh(T p0){ return false; }
+    boolean tooLow(T p0){ return false; }
+    public String toString(){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public int hashCode(){ return 0; }
+    static <T extends Comparable> GeneralRange<T> from(Range<T> p0){ return null; }
+    static <T> GeneralRange<T> all(Comparator<? super T> p0){ return null; }
+    static <T> GeneralRange<T> downTo(Comparator<? super T> p0, T p1, BoundType p2){ return null; }
+    static <T> GeneralRange<T> range(Comparator<? super T> p0, T p1, BoundType p2, T p3, BoundType p4){ return null; }
+    static <T> GeneralRange<T> upTo(Comparator<? super T> p0, T p1, BoundType p2){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/HashBasedTable.java

@@ -0,0 +1,24 @@
+// Generated automatically from com.google.common.collect.HashBasedTable for testing purposes, and manually adjusted.
+
+package com.google.common.collect;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.StandardTable;
+import com.google.common.collect.Table;
+import java.io.Serializable;
+import java.util.Map;
+
+public class HashBasedTable<R, C, V> extends StandardTable<R, C, V>
+{
+    protected HashBasedTable() {}
+    public V get(Object p0, Object p1){ return null; }
+    public V remove(Object p0, Object p1){ return null; }
+    public boolean contains(Object p0, Object p1){ return false; }
+    public boolean containsColumn(Object p0){ return false; }
+    public boolean containsRow(Object p0){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public boolean equals(Object p0){ return false; }
+    public static <R, C, V> HashBasedTable<R, C, V> create(){ return null; }
+    public static <R, C, V> HashBasedTable<R, C, V> create(Table<? extends R, ? extends C, ? extends V> p0){ return null; }
+    public static <R, C, V> HashBasedTable<R, C, V> create(int p0, int p1){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/HashBiMap.java

@@ -0,0 +1,34 @@
+// Generated automatically from com.google.common.collect.HashBiMap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.Maps;
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+
+public class HashBiMap<K, V> extends Maps.IteratorBasedAbstractMap<K, V> implements BiMap<K, V>, Serializable
+{
+    protected HashBiMap() {}
+    Iterator<Map.Entry<K, V>> entryIterator(){ return null; }
+    public BiMap<V, K> inverse(){ return null; }
+    public Set<K> keySet(){ return null; }
+    public Set<V> values(){ return null; }
+    public V forcePut(K p0, V p1){ return null; }
+    public V get(Object p0){ return null; }
+    public V put(K p0, V p1){ return null; }
+    public V remove(Object p0){ return null; }
+    public boolean containsKey(Object p0){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public int size(){ return 0; }
+    public static <K, V> HashBiMap<K, V> create(){ return null; }
+    public static <K, V> HashBiMap<K, V> create(Map<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> HashBiMap<K, V> create(int p0){ return null; }
+    public void clear(){}
+    public void forEach(BiConsumer<? super K, ? super V> p0){}
+    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/HashMultimap.java

@@ -0,0 +1,17 @@
+// Generated automatically from com.google.common.collect.HashMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.HashMultimapGwtSerializationDependencies;
+import com.google.common.collect.Multimap;
+import java.util.Set;
+
+public class HashMultimap<K, V> extends HashMultimapGwtSerializationDependencies<K, V>
+{
+    protected HashMultimap() {}
+    Set<V> createCollection(){ return null; }
+    int expectedValuesPerKey = 0;
+    public static <K, V> HashMultimap<K, V> create(){ return null; }
+    public static <K, V> HashMultimap<K, V> create(Multimap<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> HashMultimap<K, V> create(int p0, int p1){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/HashMultimapGwtSerializationDependencies.java

@@ -0,0 +1,13 @@
+// Generated automatically from com.google.common.collect.HashMultimapGwtSerializationDependencies for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractSetMultimap;
+import java.util.Collection;
+import java.util.Map;
+
+abstract class HashMultimapGwtSerializationDependencies<K, V> extends AbstractSetMultimap<K, V>
+{
+    protected HashMultimapGwtSerializationDependencies() {}
+    HashMultimapGwtSerializationDependencies(Map<K, Collection<V>> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/HashMultiset.java

@@ -0,0 +1,13 @@
+// Generated automatically from com.google.common.collect.HashMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMapBasedMultiset;
+
+public class HashMultiset<E> extends AbstractMapBasedMultiset<E>
+{
+    protected HashMultiset() {}
+    public static <E> HashMultiset<E> create(){ return null; }
+    public static <E> HashMultiset<E> create(Iterable<? extends E> p0){ return null; }
+    public static <E> HashMultiset<E> create(int p0){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableClassToInstanceMap.java

@@ -0,0 +1,28 @@
+// Generated automatically from com.google.common.collect.ImmutableClassToInstanceMap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ClassToInstanceMap;
+import com.google.common.collect.ForwardingMap;
+import java.io.Serializable;
+import java.util.Map;
+
+public class ImmutableClassToInstanceMap<B> extends ForwardingMap<Class<? extends B>, B> implements ClassToInstanceMap<B>, Serializable
+{
+    protected ImmutableClassToInstanceMap() {}
+    Object readResolve(){ return null; }
+    protected Map<Class<? extends B>, B> delegate(){ return null; }
+    public <T extends B> T getInstance(Class<T> p0){ return null; }
+    public <T extends B> T putInstance(Class<T> p0, T p1){ return null; }
+    public static <B, S extends B> ImmutableClassToInstanceMap<B> copyOf(Map<? extends Class<? extends S>, ? extends S> p0){ return null; }
+    public static <B, T extends B> ImmutableClassToInstanceMap<B> of(Class<T> p0, T p1){ return null; }
+    public static <B> ImmutableClassToInstanceMap.Builder<B> builder(){ return null; }
+    public static <B> ImmutableClassToInstanceMap<B> of(){ return null; }
+    static public class Builder<B>
+    {
+        public <T extends B> ImmutableClassToInstanceMap.Builder<B> put(Class<T> p0, T p1){ return null; }
+        public <T extends B> ImmutableClassToInstanceMap.Builder<B> putAll(Map<? extends Class<? extends T>, ? extends T> p0){ return null; }
+        public Builder(){}
+        public ImmutableClassToInstanceMap<B> build(){ return null; }
+    }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableList.java

@@ -58,8 +58,18 @@ abstract public class ImmutableList<E> extends ImmutableCollection<E> implements
     public static <E> ImmutableList<E> of(E p0, E p1, E p2, E p3, E p4, E p5, E p6, E p7, E p8, E p9, E p10, E p11, E... p12){ return null; }
     public static <E> ImmutableList<E> sortedCopyOf(Comparator<? super E> p0, Iterable<? extends E> p1){ return null; }
     public void forEach(Consumer<? super E> p0){}
+<<<<<<< HEAD
     static public class Builder<E> extends ImmutableCollection.Builder<E>
     {
+=======
+    static <E> ImmutableList<E> asImmutableList(Object[] p0){ return null; }
+    static <E> ImmutableList<E> asImmutableList(Object[] p0, int p1){ return null; }
+    static public class Builder<E> extends ImmutableCollection.Builder<E>
+    {
+        Builder(int p0){}
+        ImmutableList.Builder<E> combine(ImmutableList.Builder<E> p0){ return null; }
+        Object[] contents = null;
+>>>>>>> 2bc43eb337... Generate stubs.
         public Builder(){}
         public ImmutableList.Builder<E> add(E p0){ return null; }
         public ImmutableList.Builder<E> add(E... p0){ return null; }

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableListMultimap.java

@@ -0,0 +1,51 @@
+// Generated automatically from com.google.common.collect.ImmutableListMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Multimap;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collector;
+import java.util.stream.Stream;
+
+public class ImmutableListMultimap<K, V> extends ImmutableMultimap<K, V> implements ListMultimap<K, V>
+{
+    protected ImmutableListMultimap() {}
+    ImmutableListMultimap(ImmutableMap<K, ImmutableList<V>> p0, int p1){}
+    public ImmutableList<V> get(K p0){ return null; }
+    public ImmutableListMultimap<V, K> inverse(){ return null; }
+    public final ImmutableList<V> removeAll(Object p0){ return null; }
+    public final ImmutableList<V> replaceValues(K p0, Iterable<? extends V> p1){ return null; }
+    public static <K, V> ImmutableListMultimap.Builder<K, V> builder(){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> copyOf(Iterable<? extends Map.Entry<? extends K, ? extends V>> p0){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> copyOf(Multimap<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> of(){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> of(K p0, V p1){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> of(K p0, V p1, K p2, V p3){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5, K p6, V p7){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5, K p6, V p7, K p8, V p9){ return null; }
+    public static <T, K, V> Collector<T, ? extends Object, ImmutableListMultimap<K, V>> flatteningToImmutableListMultimap(Function<? super T, ? extends K> p0, Function<? super T, ? extends Stream<? extends V>> p1){ return null; }
+    public static <T, K, V> Collector<T, ? extends Object, ImmutableListMultimap<K, V>> toImmutableListMultimap(Function<? super T, ? extends K> p0, Function<? super T, ? extends V> p1){ return null; }
+    static <K, V> ImmutableListMultimap<K, V> fromMapEntries(Collection<? extends Map.Entry<? extends K, ? extends Collection<? extends V>>> p0, Comparator<? super V> p1){ return null; }
+    static public class Builder<K, V> extends ImmutableMultimap.Builder<K, V>
+    {
+        ImmutableListMultimap.Builder<K, V> combine(ImmutableMultimap.Builder<K, V> p0){ return null; }
+        public Builder(){}
+        public ImmutableListMultimap.Builder<K, V> orderKeysBy(Comparator<? super K> p0){ return null; }
+        public ImmutableListMultimap.Builder<K, V> orderValuesBy(Comparator<? super V> p0){ return null; }
+        public ImmutableListMultimap.Builder<K, V> put(K p0, V p1){ return null; }
+        public ImmutableListMultimap.Builder<K, V> put(Map.Entry<? extends K, ? extends V> p0){ return null; }
+        public ImmutableListMultimap.Builder<K, V> putAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> p0){ return null; }
+        public ImmutableListMultimap.Builder<K, V> putAll(K p0, Iterable<? extends V> p1){ return null; }
+        public ImmutableListMultimap.Builder<K, V> putAll(K p0, V... p1){ return null; }
+        public ImmutableListMultimap.Builder<K, V> putAll(Multimap<? extends K, ? extends V> p0){ return null; }
+        public ImmutableListMultimap<K, V> build(){ return null; }
+    }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableSortedMap.java

@@ -1,105 +1,90 @@
-/*
- * Copyright (C) 2009 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Generated automatically from com.google.common.collect.ImmutableSortedMap for testing purposes
 
 package com.google.common.collect;
 
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedMapFauxverideShim;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.collect.RegularImmutableSortedSet;
 import java.util.Comparator;
 import java.util.Map;
+import java.util.NavigableMap;
 import java.util.SortedMap;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.stream.Collector;
 
-public final class ImmutableSortedMap<K, V> extends ImmutableMap<K, V>{
-
-  public static <K, V> ImmutableSortedMap<K, V> of() {
-    return null;
-  }
-
-  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k1, V v1) {
-    return null;
-  }
-
-  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(
-      K k1, V v1, K k2, V v2) {
-    return null;
-  }
-
-  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(
-      K k1, V v1, K k2, V v2, K k3, V v3) {
-    return null;
-  }
-
-  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(
-      K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
-    return null;
-  }
-
-  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(
-      K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
-    return null;
-  }
-
-  public static <K, V> ImmutableSortedMap<K, V> copyOf(Map<? extends K, ? extends V> map) {
-    return null;
-  }
-
-  public static <K, V> ImmutableSortedMap<K, V> copyOf(
-      Map<? extends K, ? extends V> map, Comparator<? super K> comparator) {
-    return null;
-  }
-
-  public static <K, V> ImmutableSortedMap<K, V> copyOf(
-      Iterable<? extends Entry<? extends K, ? extends V>> entries) {
-    return null;
-  }
-
-  public static <K, V> ImmutableSortedMap<K, V> copyOf(
-      Iterable<? extends Entry<? extends K, ? extends V>> entries,
-      Comparator<? super K> comparator) {
-    return null;
-  }
-
-  public static <K, V> ImmutableSortedMap<K, V> copyOfSorted(SortedMap<K, ? extends V> map) {
-    return null;
-  }
-
-  @Override
-  public V get(Object key) {
-    return null;
-  }
-
-  @Override
-  public int size() {
-    return 0;
-  }
-
-  public static <K extends Comparable<?>, V> Builder<K, V> naturalOrder() {
-    return null;
-  }
-
-  public static <K, V> Builder<K, V> orderedBy(Comparator<K> comparator) {
-    return null;
-  }
-
-  public static <K extends Comparable<?>, V> Builder<K, V> reverseOrder() {
-    return null;
-  }
-
-  public static class Builder<K, V> extends ImmutableMap.Builder<K, V> {
-    public Builder(Comparator<? super K> comparator) {
+public class ImmutableSortedMap<K, V> extends ImmutableSortedMapFauxverideShim<K, V> implements NavigableMap<K, V>
+{
+    protected ImmutableSortedMap() {}
+    ImmutableCollection<V> createValues(){ return null; }
+    ImmutableSet<K> createKeySet(){ return null; }
+    ImmutableSet<Map.Entry<K, V>> createEntrySet(){ return null; }
+    ImmutableSortedMap(RegularImmutableSortedSet<K> p0, ImmutableList<V> p1){}
+    ImmutableSortedMap(RegularImmutableSortedSet<K> p0, ImmutableList<V> p1, ImmutableSortedMap<K, V> p2){}
+    Object writeReplace(){ return null; }
+    boolean isPartialView(){ return false; }
+    public Comparator<? super K> comparator(){ return null; }
+    public ImmutableCollection<V> values(){ return null; }
+    public ImmutableSet<Map.Entry<K, V>> entrySet(){ return null; }
+    public ImmutableSortedMap<K, V> descendingMap(){ return null; }
+    public ImmutableSortedMap<K, V> headMap(K p0){ return null; }
+    public ImmutableSortedMap<K, V> headMap(K p0, boolean p1){ return null; }
+    public ImmutableSortedMap<K, V> subMap(K p0, K p1){ return null; }
+    public ImmutableSortedMap<K, V> subMap(K p0, boolean p1, K p2, boolean p3){ return null; }
+    public ImmutableSortedMap<K, V> tailMap(K p0){ return null; }
+    public ImmutableSortedMap<K, V> tailMap(K p0, boolean p1){ return null; }
+    public ImmutableSortedSet<K> descendingKeySet(){ return null; }
+    public ImmutableSortedSet<K> keySet(){ return null; }
+    public ImmutableSortedSet<K> navigableKeySet(){ return null; }
+    public K ceilingKey(K p0){ return null; }
+    public K firstKey(){ return null; }
+    public K floorKey(K p0){ return null; }
+    public K higherKey(K p0){ return null; }
+    public K lastKey(){ return null; }
+    public K lowerKey(K p0){ return null; }
+    public Map.Entry<K, V> ceilingEntry(K p0){ return null; }
+    public Map.Entry<K, V> firstEntry(){ return null; }
+    public Map.Entry<K, V> floorEntry(K p0){ return null; }
+    public Map.Entry<K, V> higherEntry(K p0){ return null; }
+    public Map.Entry<K, V> lastEntry(){ return null; }
+    public Map.Entry<K, V> lowerEntry(K p0){ return null; }
+    public V get(Object p0){ return null; }
+    public final Map.Entry<K, V> pollFirstEntry(){ return null; }
+    public final Map.Entry<K, V> pollLastEntry(){ return null; }
+    public int size(){ return 0; }
+    public static <K extends Comparable<? extends Object>, V> ImmutableSortedMap.Builder<K, V> naturalOrder(){ return null; }
+    public static <K extends Comparable<? extends Object>, V> ImmutableSortedMap.Builder<K, V> reverseOrder(){ return null; }
+    public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K p0, V p1){ return null; }
+    public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3){ return null; }
+    public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5){ return null; }
+    public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5, K p6, V p7){ return null; }
+    public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5, K p6, V p7, K p8, V p9){ return null; }
+    public static <K, V> ImmutableSortedMap.Builder<K, V> orderedBy(Comparator<K> p0){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> copyOf(Iterable<? extends Map.Entry<? extends K, ? extends V>> p0){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> copyOf(Iterable<? extends Map.Entry<? extends K, ? extends V>> p0, Comparator<? super K> p1){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> copyOf(Map<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> copyOf(Map<? extends K, ? extends V> p0, Comparator<? super K> p1){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> copyOfSorted(SortedMap<K, ? extends V> p0){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> of(){ return null; }
+    public static <T, K, V> Collector<T, ? extends Object, ImmutableSortedMap<K, V>> toImmutableSortedMap(Comparator<? super K> p0, Function<? super T, ? extends K> p1, Function<? super T, ? extends V> p2){ return null; }
+    public static <T, K, V> Collector<T, ? extends Object, ImmutableSortedMap<K, V>> toImmutableSortedMap(Comparator<? super K> p0, Function<? super T, ? extends K> p1, Function<? super T, ? extends V> p2, BinaryOperator<V> p3){ return null; }
+    public void forEach(BiConsumer<? super K, ? super V> p0){}
+    static <K, V> ImmutableSortedMap<K, V> emptyMap(Comparator<? super K> p0){ return null; }
+    static public class Builder<K, V> extends ImmutableMap.Builder<K, V>
+    {
+        protected Builder() {}
+        ImmutableSortedMap.Builder<K, V> combine(ImmutableMap.Builder<K, V> p0){ return null; }
+        public Builder(Comparator<? super K> p0){}
+        public ImmutableSortedMap.Builder<K, V> put(K p0, V p1){ return null; }
+        public ImmutableSortedMap.Builder<K, V> put(Map.Entry<? extends K, ? extends V> p0){ return null; }
+        public ImmutableSortedMap.Builder<K, V> putAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> p0){ return null; }
+        public ImmutableSortedMap.Builder<K, V> putAll(Map<? extends K, ? extends V> p0){ return null; }
+        public ImmutableSortedMap<K, V> build(){ return null; }
+        public final ImmutableSortedMap.Builder<K, V> orderEntriesByValue(Comparator<? super V> p0){ return null; }
     }
-
-  }
-
 }

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableSortedMapFauxverideShim.java

@@ -0,0 +1,23 @@
+// Generated automatically from com.google.common.collect.ImmutableSortedMapFauxverideShim for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedMap;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.stream.Collector;
+
+abstract class ImmutableSortedMapFauxverideShim<K, V> extends ImmutableMap<K, V>
+{
+    ImmutableSortedMapFauxverideShim(){}
+    public static <K, V> ImmutableSortedMap.Builder<K, V> builder(){ return null; }
+    public static <K, V> ImmutableSortedMap.Builder<K, V> builderWithExpectedSize(int p0){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> of(K p0, V p1){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5, K p6, V p7){ return null; }
+    public static <K, V> ImmutableSortedMap<K, V> of(K p0, V p1, K p2, V p3, K p4, V p5, K p6, V p7, K p8, V p9){ return null; }
+    public static <T, K, V> Collector<T, ? extends Object, ImmutableMap<K, V>> toImmutableMap(Function<? super T, ? extends K> p0, Function<? super T, ? extends V> p1){ return null; }
+    public static <T, K, V> Collector<T, ? extends Object, ImmutableMap<K, V>> toImmutableMap(Function<? super T, ? extends K> p0, Function<? super T, ? extends V> p1, BinaryOperator<V> p2){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableSortedMultiset.java

@@ -0,0 +1,61 @@
+// Generated automatically from com.google.common.collect.ImmutableSortedMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.BoundType;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.ImmutableSortedMultisetFauxverideShim;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.SortedMultiset;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.function.Function;
+import java.util.function.ToIntFunction;
+import java.util.stream.Collector;
+
+abstract public class ImmutableSortedMultiset<E> extends ImmutableSortedMultisetFauxverideShim<E> implements SortedMultiset<E>
+{
+    ImmutableSortedMultiset(){}
+    ImmutableSortedMultiset<E> descendingMultiset = null;
+    Object writeReplace(){ return null; }
+    public ImmutableSortedMultiset<E> descendingMultiset(){ return null; }
+    public ImmutableSortedMultiset<E> subMultiset(E p0, BoundType p1, E p2, BoundType p3){ return null; }
+    public abstract ImmutableSortedMultiset<E> headMultiset(E p0, BoundType p1);
+    public abstract ImmutableSortedMultiset<E> tailMultiset(E p0, BoundType p1);
+    public abstract ImmutableSortedSet<E> elementSet();
+    public final Comparator<? super E> comparator(){ return null; }
+    public final Multiset.Entry<E> pollFirstEntry(){ return null; }
+    public final Multiset.Entry<E> pollLastEntry(){ return null; }
+    public static <E extends Comparable<? extends Object>> ImmutableSortedMultiset.Builder<E> naturalOrder(){ return null; }
+    public static <E extends Comparable<? extends Object>> ImmutableSortedMultiset.Builder<E> reverseOrder(){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> copyOf(E[] p0){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E p0){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E p0, E p1){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E p0, E p1, E p2){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E p0, E p1, E p2, E p3){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E p0, E p1, E p2, E p3, E p4){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E p0, E p1, E p2, E p3, E p4, E p5, E... p6){ return null; }
+    public static <E> Collector<E, ? extends Object, ImmutableSortedMultiset<E>> toImmutableSortedMultiset(Comparator<? super E> p0){ return null; }
+    public static <E> ImmutableSortedMultiset.Builder<E> orderedBy(Comparator<E> p0){ return null; }
+    public static <E> ImmutableSortedMultiset<E> copyOf(Comparator<? super E> p0, Iterable<? extends E> p1){ return null; }
+    public static <E> ImmutableSortedMultiset<E> copyOf(Comparator<? super E> p0, Iterator<? extends E> p1){ return null; }
+    public static <E> ImmutableSortedMultiset<E> copyOf(Iterable<? extends E> p0){ return null; }
+    public static <E> ImmutableSortedMultiset<E> copyOf(Iterator<? extends E> p0){ return null; }
+    public static <E> ImmutableSortedMultiset<E> copyOfSorted(SortedMultiset<E> p0){ return null; }
+    public static <E> ImmutableSortedMultiset<E> of(){ return null; }
+    public static <T, E> Collector<T, ? extends Object, ImmutableSortedMultiset<E>> toImmutableSortedMultiset(Comparator<? super E> p0, Function<? super T, ? extends E> p1, ToIntFunction<? super T> p2){ return null; }
+    static <E> ImmutableSortedMultiset<E> emptyMultiset(Comparator<? super E> p0){ return null; }
+    static public class Builder<E> extends ImmutableMultiset.Builder<E>
+    {
+        protected Builder() {}
+        public Builder(Comparator<? super E> p0){}
+        public ImmutableSortedMultiset.Builder<E> add(E p0){ return null; }
+        public ImmutableSortedMultiset.Builder<E> add(E... p0){ return null; }
+        public ImmutableSortedMultiset.Builder<E> addAll(Iterable<? extends E> p0){ return null; }
+        public ImmutableSortedMultiset.Builder<E> addAll(Iterator<? extends E> p0){ return null; }
+        public ImmutableSortedMultiset.Builder<E> addCopies(E p0, int p1){ return null; }
+        public ImmutableSortedMultiset.Builder<E> setCount(E p0, int p1){ return null; }
+        public ImmutableSortedMultiset<E> build(){ return null; }
+    }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableSortedMultisetFauxverideShim.java

@@ -0,0 +1,24 @@
+// Generated automatically from com.google.common.collect.ImmutableSortedMultisetFauxverideShim for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.ImmutableSortedMultiset;
+import java.util.function.Function;
+import java.util.function.ToIntFunction;
+import java.util.stream.Collector;
+
+abstract class ImmutableSortedMultisetFauxverideShim<E> extends ImmutableMultiset<E>
+{
+    ImmutableSortedMultisetFauxverideShim(){}
+    public static <E> Collector<E, ? extends Object, ImmutableMultiset<E>> toImmutableMultiset(){ return null; }
+    public static <E> ImmutableSortedMultiset.Builder<E> builder(){ return null; }
+    public static <E> ImmutableSortedMultiset<E> copyOf(E[] p0){ return null; }
+    public static <E> ImmutableSortedMultiset<E> of(E p0){ return null; }
+    public static <E> ImmutableSortedMultiset<E> of(E p0, E p1){ return null; }
+    public static <E> ImmutableSortedMultiset<E> of(E p0, E p1, E p2){ return null; }
+    public static <E> ImmutableSortedMultiset<E> of(E p0, E p1, E p2, E p3){ return null; }
+    public static <E> ImmutableSortedMultiset<E> of(E p0, E p1, E p2, E p3, E p4){ return null; }
+    public static <E> ImmutableSortedMultiset<E> of(E p0, E p1, E p2, E p3, E p4, E p5, E... p6){ return null; }
+    public static <T, E> Collector<T, ? extends Object, ImmutableMultiset<E>> toImmutableMultiset(Function<? super T, ? extends E> p0, ToIntFunction<? super T> p1){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableSortedSet.java

@@ -1,111 +1,85 @@
-/*
- * Copyright (C) 2008 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Generated automatically from com.google.common.collect.ImmutableSortedSet for testing purposes
 
 package com.google.common.collect;
 
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSetFauxverideShim;
+import com.google.common.collect.RegularImmutableSortedSet;
+import com.google.common.collect.SortedIterable;
+import com.google.common.collect.UnmodifiableIterator;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NavigableSet;
 import java.util.SortedSet;
+import java.util.Spliterator;
+import java.util.stream.Collector;
 
-public abstract class ImmutableSortedSet<E> extends ImmutableSet<E>
-    implements NavigableSet<E> {
-  
-  public static <E> ImmutableSortedSet<E> of() {
-    return null;
-  }
-
-  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E element) {
-    return null;
-  }
-
-  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1, E e2) {
-    return null;
-  }
-
-  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1, E e2, E e3) {
-    return null;
-  }
-
-  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1, E e2, E e3, E e4) {
-    return null;
-  }
-
-  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
-      E e1, E e2, E e3, E e4, E e5) {
-    return null;
-  }
-
-  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
-      E e1, E e2, E e3, E e4, E e5, E e6, E... remaining) {
-    return null;
-  }
-
-  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> copyOf(E[] elements) {
-    return null;
-  }
-
-  public static <E> ImmutableSortedSet<E> copyOf(Iterable<? extends E> elements) {
-    return null;
-  }
-
-  public static <E> ImmutableSortedSet<E> copyOf(Collection<? extends E> elements) {
-    return null;
-  }
-
-  public static <E> ImmutableSortedSet<E> copyOf(Iterator<? extends E> elements) {
-    return null;
-  }
-
-  public static <E> ImmutableSortedSet<E> copyOf(
-      Comparator<? super E> comparator, Iterator<? extends E> elements) {
-    return null;
-  }
-
-  public static <E> ImmutableSortedSet<E> copyOf(
-      Comparator<? super E> comparator, Iterable<? extends E> elements) {
-    return null;
-  }
-
-  public static <E> ImmutableSortedSet<E> copyOf(
-      Comparator<? super E> comparator, Collection<? extends E> elements) {
-    return null;
-  }
-
-  public static <E> ImmutableSortedSet<E> copyOfSorted(SortedSet<E> sortedSet) {
-    return null;
-  }
-
-  public static <E> Builder<E> orderedBy(Comparator<E> comparator) {
-    return null;
-  }
-
-  public static <E extends Comparable<?>> Builder<E> reverseOrder() {
-    return null;
-  }
-
-  public static <E extends Comparable<?>> Builder<E> naturalOrder() {
-    return null;
-  }
-
-  public static final class Builder<E> extends ImmutableSet.Builder<E> {
-    public Builder(Comparator<? super E> comparator) {
+abstract public class ImmutableSortedSet<E> extends ImmutableSortedSetFauxverideShim<E> implements NavigableSet<E>, SortedIterable<E>
+{
+    protected ImmutableSortedSet() {}
+    ImmutableSortedSet(Comparator<? super E> p0){}
+    ImmutableSortedSet<E> descendingSet = null;
+    Object writeReplace(){ return null; }
+    abstract ImmutableSortedSet<E> createDescendingSet();
+    abstract ImmutableSortedSet<E> headSetImpl(E p0, boolean p1);
+    abstract ImmutableSortedSet<E> subSetImpl(E p0, boolean p1, E p2, boolean p3);
+    abstract ImmutableSortedSet<E> tailSetImpl(E p0, boolean p1);
+    abstract int indexOf(Object p0);
+    final Comparator<? super E> comparator = null;
+    int unsafeCompare(Object p0, Object p1){ return 0; }
+    public Comparator<? super E> comparator(){ return null; }
+    public E ceiling(E p0){ return null; }
+    public E first(){ return null; }
+    public E floor(E p0){ return null; }
+    public E higher(E p0){ return null; }
+    public E last(){ return null; }
+    public E lower(E p0){ return null; }
+    public ImmutableSortedSet<E> descendingSet(){ return null; }
+    public ImmutableSortedSet<E> headSet(E p0){ return null; }
+    public ImmutableSortedSet<E> headSet(E p0, boolean p1){ return null; }
+    public ImmutableSortedSet<E> subSet(E p0, E p1){ return null; }
+    public ImmutableSortedSet<E> subSet(E p0, boolean p1, E p2, boolean p3){ return null; }
+    public ImmutableSortedSet<E> tailSet(E p0){ return null; }
+    public ImmutableSortedSet<E> tailSet(E p0, boolean p1){ return null; }
+    public Spliterator<E> spliterator(){ return null; }
+    public abstract UnmodifiableIterator<E> descendingIterator();
+    public abstract UnmodifiableIterator<E> iterator();
+    public final E pollFirst(){ return null; }
+    public final E pollLast(){ return null; }
+    public static <E extends Comparable<? extends Object>> ImmutableSortedSet.Builder<E> naturalOrder(){ return null; }
+    public static <E extends Comparable<? extends Object>> ImmutableSortedSet.Builder<E> reverseOrder(){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedSet<E> copyOf(E[] p0){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E p0){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E p0, E p1){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E p0, E p1, E p2){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E p0, E p1, E p2, E p3){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E p0, E p1, E p2, E p3, E p4){ return null; }
+    public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E p0, E p1, E p2, E p3, E p4, E p5, E... p6){ return null; }
+    public static <E> Collector<E, ? extends Object, ImmutableSortedSet<E>> toImmutableSortedSet(Comparator<? super E> p0){ return null; }
+    public static <E> ImmutableSortedSet.Builder<E> orderedBy(Comparator<E> p0){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOf(Collection<? extends E> p0){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> p0, Collection<? extends E> p1){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> p0, Iterable<? extends E> p1){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> p0, Iterator<? extends E> p1){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOf(Iterable<? extends E> p0){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOf(Iterator<? extends E> p0){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOfSorted(SortedSet<E> p0){ return null; }
+    public static <E> ImmutableSortedSet<E> of(){ return null; }
+    static <E> ImmutableSortedSet<E> construct(Comparator<? super E> p0, int p1, E... p2){ return null; }
+    static <E> RegularImmutableSortedSet<E> emptySet(Comparator<? super E> p0){ return null; }
+    static int SPLITERATOR_CHARACTERISTICS = 0;
+    static int unsafeCompare(Comparator<? extends Object> p0, Object p1, Object p2){ return 0; }
+    static public class Builder<E> extends ImmutableSet.Builder<E>
+    {
+        protected Builder() {}
+        ImmutableSortedSet.Builder<E> combine(ImmutableSet.Builder<E> p0){ return null; }
+        public Builder(Comparator<? super E> p0){}
+        public ImmutableSortedSet.Builder<E> add(E p0){ return null; }
+        public ImmutableSortedSet.Builder<E> add(E... p0){ return null; }
+        public ImmutableSortedSet.Builder<E> addAll(Iterable<? extends E> p0){ return null; }
+        public ImmutableSortedSet.Builder<E> addAll(Iterator<? extends E> p0){ return null; }
+        public ImmutableSortedSet<E> build(){ return null; }
+        void copy(){}
     }
-
-  }
-
 }

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableSortedSetFauxverideShim.java

@@ -0,0 +1,22 @@
+// Generated automatically from com.google.common.collect.ImmutableSortedSetFauxverideShim for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import java.util.stream.Collector;
+
+abstract class ImmutableSortedSetFauxverideShim<E> extends ImmutableSet<E>
+{
+    ImmutableSortedSetFauxverideShim(){}
+    public static <E> Collector<E, ? extends Object, ImmutableSet<E>> toImmutableSet(){ return null; }
+    public static <E> ImmutableSortedSet.Builder<E> builder(){ return null; }
+    public static <E> ImmutableSortedSet.Builder<E> builderWithExpectedSize(int p0){ return null; }
+    public static <E> ImmutableSortedSet<E> copyOf(E[] p0){ return null; }
+    public static <E> ImmutableSortedSet<E> of(E p0){ return null; }
+    public static <E> ImmutableSortedSet<E> of(E p0, E p1){ return null; }
+    public static <E> ImmutableSortedSet<E> of(E p0, E p1, E p2){ return null; }
+    public static <E> ImmutableSortedSet<E> of(E p0, E p1, E p2, E p3){ return null; }
+    public static <E> ImmutableSortedSet<E> of(E p0, E p1, E p2, E p3, E p4){ return null; }
+    public static <E> ImmutableSortedSet<E> of(E p0, E p1, E p2, E p3, E p4, E p5, E... p6){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ImmutableTable.java

@@ -1,124 +1,69 @@
-/*
- * Copyright (C) 2009 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Generated automatically from com.google.common.collect.ImmutableTable for testing purposes
 
 package com.google.common.collect;
 
+import com.google.common.collect.AbstractTable;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Table;
+import com.google.common.collect.UnmodifiableIterator;
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.Iterator;
 import java.util.Map;
+import java.util.Spliterator;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.stream.Collector;
 
-public abstract class ImmutableTable<R, C, V> extends AbstractTable<R, C, V> {
-
-  public static <R, C, V> ImmutableTable<R, C, V> of() {
-    return null;
-  }
-
-  public static <R, C, V> ImmutableTable<R, C, V> of(R rowKey, C columnKey, V value) {
-    return null;
-  }
-
-  public static <R, C, V> ImmutableTable<R, C, V> copyOf(
-      Table<? extends R, ? extends C, ? extends V> table) {
-    return null;
-  }
-
-  public static <R, C, V> Builder<R, C, V> builder() {
-    return null;
-  }
-
-  public static final class Builder<R, C, V> {
-    public Builder() {}
-
-    public Builder<R, C, V> put(R rowKey, C columnKey, V value) {
-      return null;
+abstract public class ImmutableTable<R, C, V> extends AbstractTable<R, C, V> implements Serializable
+{
+    ImmutableTable(){}
+    abstract ImmutableCollection<V> createValues();
+    abstract ImmutableSet<Table.Cell<R, C, V>> createCellSet();
+    abstract ImmutableTable.SerializedForm createSerializedForm();
+    final Iterator<V> valuesIterator(){ return null; }
+    final Object writeReplace(){ return null; }
+    final Spliterator<Table.Cell<R, C, V>> cellSpliterator(){ return null; }
+    final UnmodifiableIterator<Table.Cell<R, C, V>> cellIterator(){ return null; }
+    public ImmutableCollection<V> values(){ return null; }
+    public ImmutableMap<C, V> row(R p0){ return null; }
+    public ImmutableMap<R, V> column(C p0){ return null; }
+    public ImmutableSet<C> columnKeySet(){ return null; }
+    public ImmutableSet<R> rowKeySet(){ return null; }
+    public ImmutableSet<Table.Cell<R, C, V>> cellSet(){ return null; }
+    public abstract ImmutableMap<C, Map<R, V>> columnMap();
+    public abstract ImmutableMap<R, Map<C, V>> rowMap();
+    public boolean contains(Object p0, Object p1){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public final V put(R p0, C p1, V p2){ return null; }
+    public final V remove(Object p0, Object p1){ return null; }
+    public final void clear(){}
+    public final void putAll(Table<? extends R, ? extends C, ? extends V> p0){}
+    public static <R, C, V> ImmutableTable.Builder<R, C, V> builder(){ return null; }
+    public static <R, C, V> ImmutableTable<R, C, V> copyOf(Table<? extends R, ? extends C, ? extends V> p0){ return null; }
+    public static <R, C, V> ImmutableTable<R, C, V> of(){ return null; }
+    public static <R, C, V> ImmutableTable<R, C, V> of(R p0, C p1, V p2){ return null; }
+    public static <T, R, C, V> Collector<T, ? extends Object, ImmutableTable<R, C, V>> toImmutableTable(Function<? super T, ? extends R> p0, Function<? super T, ? extends C> p1, Function<? super T, ? extends V> p2){ return null; }
+    public static <T, R, C, V> Collector<T, ? extends Object, ImmutableTable<R, C, V>> toImmutableTable(Function<? super T, ? extends R> p0, Function<? super T, ? extends C> p1, Function<? super T, ? extends V> p2, BinaryOperator<V> p3){ return null; }
+    static <R, C, V> ImmutableTable<R, C, V> copyOf(Iterable<? extends Table.Cell<? extends R, ? extends C, ? extends V>> p0){ return null; }
+    static <R, C, V> Table.Cell<R, C, V> cellOf(R p0, C p1, V p2){ return null; }
+    static class SerializedForm implements Serializable
+    {
+        protected SerializedForm() {}
+        Object readResolve(){ return null; }
+        static ImmutableTable.SerializedForm create(ImmutableTable<? extends Object, ? extends Object, ? extends Object> p0, int[] p1, int[] p2){ return null; }
     }
-
-    public Builder<R, C, V> put(Cell<? extends R, ? extends C, ? extends V> cell) {
-      return null;
+    static public class Builder<R, C, V>
+    {
+        ImmutableTable.Builder<R, C, V> combine(ImmutableTable.Builder<R, C, V> p0){ return null; }
+        public Builder(){}
+        public ImmutableTable.Builder<R, C, V> orderColumnsBy(Comparator<? super C> p0){ return null; }
+        public ImmutableTable.Builder<R, C, V> orderRowsBy(Comparator<? super R> p0){ return null; }
+        public ImmutableTable.Builder<R, C, V> put(R p0, C p1, V p2){ return null; }
+        public ImmutableTable.Builder<R, C, V> put(Table.Cell<? extends R, ? extends C, ? extends V> p0){ return null; }
+        public ImmutableTable.Builder<R, C, V> putAll(Table<? extends R, ? extends C, ? extends V> p0){ return null; }
+        public ImmutableTable<R, C, V> build(){ return null; }
     }
-
-    public Builder<R, C, V> putAll(Table<? extends R, ? extends C, ? extends V> table) {
-      return null;
-    }
-
-    public ImmutableTable<R, C, V> build() {
-      return null;
-    }
-
-  }
-  @Override
-  public ImmutableSet<Cell<R, C, V>> cellSet() {
-    return null;
-  }
-
-  @Override
-  public ImmutableCollection<V> values() {
-    return null;
-  }
-
-  @Override
-  public ImmutableMap<R, V> column(C columnKey) {
-    return null;
-  }
-
-  @Override
-  public ImmutableSet<C> columnKeySet() {
-    return null;
-  }
-
-  @Override
-  public abstract ImmutableMap<C, Map<R, V>> columnMap();
-
-  @Override
-  public ImmutableMap<C, V> row(R rowKey) {
-    return null;
-  }
-
-  @Override
-  public ImmutableSet<R> rowKeySet() {
-    return null;
-  }
-
-  @Override
-  public abstract ImmutableMap<R, Map<C, V>> rowMap();
-
-  @Override
-  public boolean contains(Object rowKey, Object columnKey) {
-    return false;
-  }
-
-  @Override
-  public boolean containsValue(Object value) {
-    return false;
-  }
-
-  @Override
-  public final void clear() {
-  }
-
-  @Override
-  public final V put(R rowKey, C columnKey, V value) {
-    return null;
-  }
-
-  @Override
-  public final void putAll(Table<? extends R, ? extends C, ? extends V> table) {
-  }
-
-  @Override
-  public final V remove(Object rowKey, Object columnKey) {
-    return null;
-  }
-
 }

java/ql/test/stubs/guava-30.0/com/google/common/collect/Iterables.java

@@ -0,0 +1,63 @@
+// Generated automatically from com.google.common.collect.Iterables for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableCollection;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+
+public class Iterables
+{
+    protected Iterables() {}
+    public static <E> Iterable<E> unmodifiableIterable(ImmutableCollection<E> p0){ return null; }
+    public static <F, T> Iterable<T> transform(Iterable<F> p0, Function<? super F, ? extends T> p1){ return null; }
+    public static <T> Iterable<List<T>> paddedPartition(Iterable<T> p0, int p1){ return null; }
+    public static <T> Iterable<List<T>> partition(Iterable<T> p0, int p1){ return null; }
+    public static <T> Iterable<T> concat(Iterable<? extends Iterable<? extends T>> p0){ return null; }
+    public static <T> Iterable<T> concat(Iterable<? extends T> p0, Iterable<? extends T> p1){ return null; }
+    public static <T> Iterable<T> concat(Iterable<? extends T> p0, Iterable<? extends T> p1, Iterable<? extends T> p2){ return null; }
+    public static <T> Iterable<T> concat(Iterable<? extends T> p0, Iterable<? extends T> p1, Iterable<? extends T> p2, Iterable<? extends T> p3){ return null; }
+    public static <T> Iterable<T> concat(Iterable<? extends T>... p0){ return null; }
+    public static <T> Iterable<T> consumingIterable(Iterable<T> p0){ return null; }
+    public static <T> Iterable<T> cycle(Iterable<T> p0){ return null; }
+    public static <T> Iterable<T> cycle(T... p0){ return null; }
+    public static <T> Iterable<T> filter(Iterable<? extends Object> p0, Class<T> p1){ return null; }
+    public static <T> Iterable<T> filter(Iterable<T> p0, Predicate<? super T> p1){ return null; }
+    public static <T> Iterable<T> limit(Iterable<T> p0, int p1){ return null; }
+    public static <T> Iterable<T> mergeSorted(Iterable<? extends Iterable<? extends T>> p0, Comparator<? super T> p1){ return null; }
+    public static <T> Iterable<T> skip(Iterable<T> p0, int p1){ return null; }
+    public static <T> Iterable<T> unmodifiableIterable(Iterable<? extends T> p0){ return null; }
+    public static <T> Optional<T> tryFind(Iterable<T> p0, Predicate<? super T> p1){ return null; }
+    public static <T> T find(Iterable<? extends T> p0, Predicate<? super T> p1, T p2){ return null; }
+    public static <T> T find(Iterable<T> p0, Predicate<? super T> p1){ return null; }
+    public static <T> T get(Iterable<? extends T> p0, int p1, T p2){ return null; }
+    public static <T> T get(Iterable<T> p0, int p1){ return null; }
+    public static <T> T getFirst(Iterable<? extends T> p0, T p1){ return null; }
+    public static <T> T getLast(Iterable<? extends T> p0, T p1){ return null; }
+    public static <T> T getLast(Iterable<T> p0){ return null; }
+    public static <T> T getOnlyElement(Iterable<? extends T> p0, T p1){ return null; }
+    public static <T> T getOnlyElement(Iterable<T> p0){ return null; }
+    public static <T> T[] toArray(Iterable<? extends T> p0, Class<T> p1){ return null; }
+    public static <T> boolean addAll(Collection<T> p0, Iterable<? extends T> p1){ return false; }
+    public static <T> boolean all(Iterable<T> p0, Predicate<? super T> p1){ return false; }
+    public static <T> boolean any(Iterable<T> p0, Predicate<? super T> p1){ return false; }
+    public static <T> boolean removeIf(Iterable<T> p0, Predicate<? super T> p1){ return false; }
+    public static <T> int indexOf(Iterable<T> p0, Predicate<? super T> p1){ return 0; }
+    public static String toString(Iterable<? extends Object> p0){ return null; }
+    public static boolean contains(Iterable<? extends Object> p0, Object p1){ return false; }
+    public static boolean elementsEqual(Iterable<? extends Object> p0, Iterable<? extends Object> p1){ return false; }
+    public static boolean isEmpty(Iterable<? extends Object> p0){ return false; }
+    public static boolean removeAll(Iterable<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static boolean retainAll(Iterable<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static int frequency(Iterable<? extends Object> p0, Object p1){ return 0; }
+    public static int size(Iterable<? extends Object> p0){ return 0; }
+    static <T> Function<Iterable<? extends T>, Iterator<? extends T>> toIterator(){ return null; }
+    static <T> T removeFirstMatching(Iterable<T> p0, Predicate<? super T> p1){ return null; }
+    static <T> T[] toArray(Iterable<? extends T> p0, T[] p1){ return null; }
+    static Object[] toArray(Iterable<? extends Object> p0){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Iterators.java

@@ -0,0 +1,77 @@
+// Generated automatically from com.google.common.collect.Iterators for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.PeekingIterator;
+import com.google.common.collect.UnmodifiableIterator;
+import com.google.common.collect.UnmodifiableListIterator;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class Iterators
+{
+    protected Iterators() {}
+    public static <F, T> Iterator<T> transform(Iterator<F> p0, Function<? super F, ? extends T> p1){ return null; }
+    public static <T> Enumeration<T> asEnumeration(Iterator<T> p0){ return null; }
+    public static <T> Iterator<T> concat(Iterator<? extends Iterator<? extends T>> p0){ return null; }
+    public static <T> Iterator<T> concat(Iterator<? extends T> p0, Iterator<? extends T> p1){ return null; }
+    public static <T> Iterator<T> concat(Iterator<? extends T> p0, Iterator<? extends T> p1, Iterator<? extends T> p2){ return null; }
+    public static <T> Iterator<T> concat(Iterator<? extends T> p0, Iterator<? extends T> p1, Iterator<? extends T> p2, Iterator<? extends T> p3){ return null; }
+    public static <T> Iterator<T> concat(Iterator<? extends T>... p0){ return null; }
+    public static <T> Iterator<T> consumingIterator(Iterator<T> p0){ return null; }
+    public static <T> Iterator<T> cycle(Iterable<T> p0){ return null; }
+    public static <T> Iterator<T> cycle(T... p0){ return null; }
+    public static <T> Iterator<T> limit(Iterator<T> p0, int p1){ return null; }
+    public static <T> Optional<T> tryFind(Iterator<T> p0, Predicate<? super T> p1){ return null; }
+    public static <T> PeekingIterator<T> peekingIterator(Iterator<? extends T> p0){ return null; }
+    public static <T> PeekingIterator<T> peekingIterator(PeekingIterator<T> p0){ return null; }
+    public static <T> T find(Iterator<? extends T> p0, Predicate<? super T> p1, T p2){ return null; }
+    public static <T> T find(Iterator<T> p0, Predicate<? super T> p1){ return null; }
+    public static <T> T get(Iterator<? extends T> p0, int p1, T p2){ return null; }
+    public static <T> T get(Iterator<T> p0, int p1){ return null; }
+    public static <T> T getLast(Iterator<? extends T> p0, T p1){ return null; }
+    public static <T> T getLast(Iterator<T> p0){ return null; }
+    public static <T> T getNext(Iterator<? extends T> p0, T p1){ return null; }
+    public static <T> T getOnlyElement(Iterator<? extends T> p0, T p1){ return null; }
+    public static <T> T getOnlyElement(Iterator<T> p0){ return null; }
+    public static <T> T[] toArray(Iterator<? extends T> p0, Class<T> p1){ return null; }
+    public static <T> UnmodifiableIterator<List<T>> paddedPartition(Iterator<T> p0, int p1){ return null; }
+    public static <T> UnmodifiableIterator<List<T>> partition(Iterator<T> p0, int p1){ return null; }
+    public static <T> UnmodifiableIterator<T> filter(Iterator<? extends Object> p0, Class<T> p1){ return null; }
+    public static <T> UnmodifiableIterator<T> filter(Iterator<T> p0, Predicate<? super T> p1){ return null; }
+    public static <T> UnmodifiableIterator<T> forArray(T... p0){ return null; }
+    public static <T> UnmodifiableIterator<T> forEnumeration(Enumeration<T> p0){ return null; }
+    public static <T> UnmodifiableIterator<T> mergeSorted(Iterable<? extends Iterator<? extends T>> p0, Comparator<? super T> p1){ return null; }
+    public static <T> UnmodifiableIterator<T> singletonIterator(T p0){ return null; }
+    public static <T> UnmodifiableIterator<T> unmodifiableIterator(Iterator<? extends T> p0){ return null; }
+    public static <T> UnmodifiableIterator<T> unmodifiableIterator(UnmodifiableIterator<T> p0){ return null; }
+    public static <T> boolean addAll(Collection<T> p0, Iterator<? extends T> p1){ return false; }
+    public static <T> boolean all(Iterator<T> p0, Predicate<? super T> p1){ return false; }
+    public static <T> boolean any(Iterator<T> p0, Predicate<? super T> p1){ return false; }
+    public static <T> boolean removeIf(Iterator<T> p0, Predicate<? super T> p1){ return false; }
+    public static <T> int indexOf(Iterator<T> p0, Predicate<? super T> p1){ return 0; }
+    public static String toString(Iterator<? extends Object> p0){ return null; }
+    public static boolean contains(Iterator<? extends Object> p0, Object p1){ return false; }
+    public static boolean elementsEqual(Iterator<? extends Object> p0, Iterator<? extends Object> p1){ return false; }
+    public static boolean removeAll(Iterator<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static boolean retainAll(Iterator<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    public static int advance(Iterator<? extends Object> p0, int p1){ return 0; }
+    public static int frequency(Iterator<? extends Object> p0, Object p1){ return 0; }
+    public static int size(Iterator<? extends Object> p0){ return 0; }
+    static <T> Iterator<T> concatNoDefensiveCopy(Iterator<? extends T>... p0){ return null; }
+    static <T> Iterator<T> emptyModifiableIterator(){ return null; }
+    static <T> ListIterator<T> cast(Iterator<T> p0){ return null; }
+    static <T> T pollNext(Iterator<T> p0){ return null; }
+    static <T> UnmodifiableIterator<T> emptyIterator(){ return null; }
+    static <T> UnmodifiableListIterator<T> emptyListIterator(){ return null; }
+    static <T> UnmodifiableListIterator<T> forArray(T[] p0, int p1, int p2, int p3){ return null; }
+    static void checkNonnegative(int p0){}
+    static void clear(Iterator<? extends Object> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/LinkedHashMultimap.java

@@ -0,0 +1,32 @@
+// Generated automatically from com.google.common.collect.LinkedHashMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.LinkedHashMultimapGwtSerializationDependencies;
+import com.google.common.collect.Multimap;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Spliterator;
+
+public class LinkedHashMultimap<K, V> extends LinkedHashMultimapGwtSerializationDependencies<K, V>
+{
+    protected LinkedHashMultimap() {}
+    Collection<V> createCollection(K p0){ return null; }
+    Iterator<Map.Entry<K, V>> entryIterator(){ return null; }
+    Iterator<V> valueIterator(){ return null; }
+    Set<V> createCollection(){ return null; }
+    Spliterator<Map.Entry<K, V>> entrySpliterator(){ return null; }
+    Spliterator<V> valueSpliterator(){ return null; }
+    int valueSetCapacity = 0;
+    public Collection<V> values(){ return null; }
+    public Set<K> keySet(){ return null; }
+    public Set<Map.Entry<K, V>> entries(){ return null; }
+    public Set<V> replaceValues(K p0, Iterable<? extends V> p1){ return null; }
+    public static <K, V> LinkedHashMultimap<K, V> create(){ return null; }
+    public static <K, V> LinkedHashMultimap<K, V> create(Multimap<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> LinkedHashMultimap<K, V> create(int p0, int p1){ return null; }
+    public void clear(){}
+    static double VALUE_SET_LOAD_FACTOR = 0;
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/LinkedHashMultimapGwtSerializationDependencies.java

@@ -0,0 +1,13 @@
+// Generated automatically from com.google.common.collect.LinkedHashMultimapGwtSerializationDependencies for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractSetMultimap;
+import java.util.Collection;
+import java.util.Map;
+
+abstract class LinkedHashMultimapGwtSerializationDependencies<K, V> extends AbstractSetMultimap<K, V>
+{
+    protected LinkedHashMultimapGwtSerializationDependencies() {}
+    LinkedHashMultimapGwtSerializationDependencies(Map<K, Collection<V>> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/LinkedHashMultiset.java

@@ -0,0 +1,13 @@
+// Generated automatically from com.google.common.collect.LinkedHashMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMapBasedMultiset;
+
+public class LinkedHashMultiset<E> extends AbstractMapBasedMultiset<E>
+{
+    protected LinkedHashMultiset() {}
+    public static <E> LinkedHashMultiset<E> create(){ return null; }
+    public static <E> LinkedHashMultiset<E> create(Iterable<? extends E> p0){ return null; }
+    public static <E> LinkedHashMultiset<E> create(int p0){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/LinkedListMultimap.java

@@ -0,0 +1,39 @@
+// Generated automatically from com.google.common.collect.LinkedListMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractMultimap;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multiset;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class LinkedListMultimap<K, V> extends AbstractMultimap<K, V> implements ListMultimap<K, V>, Serializable
+{
+    Iterator<Map.Entry<K, V>> entryIterator(){ return null; }
+    LinkedListMultimap(){}
+    List<Map.Entry<K, V>> createEntries(){ return null; }
+    List<V> createValues(){ return null; }
+    Map<K, Collection<V>> createAsMap(){ return null; }
+    Multiset<K> createKeys(){ return null; }
+    Set<K> createKeySet(){ return null; }
+    public List<Map.Entry<K, V>> entries(){ return null; }
+    public List<V> get(K p0){ return null; }
+    public List<V> removeAll(Object p0){ return null; }
+    public List<V> replaceValues(K p0, Iterable<? extends V> p1){ return null; }
+    public List<V> values(){ return null; }
+    public boolean containsKey(Object p0){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public boolean put(K p0, V p1){ return false; }
+    public int size(){ return 0; }
+    public static <K, V> LinkedListMultimap<K, V> create(){ return null; }
+    public static <K, V> LinkedListMultimap<K, V> create(Multimap<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> LinkedListMultimap<K, V> create(int p0){ return null; }
+    public void clear(){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/ListMultimap.java

@@ -0,0 +1,17 @@
+// Generated automatically from com.google.common.collect.ListMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.Multimap;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public interface ListMultimap<K, V> extends Multimap<K, V>
+{
+    List<V> get(K p0);
+    List<V> removeAll(Object p0);
+    List<V> replaceValues(K p0, Iterable<? extends V> p1);
+    Map<K, Collection<V>> asMap();
+    boolean equals(Object p0);
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Lists.java

@@ -0,0 +1,45 @@
+// Generated automatically from com.google.common.collect.Lists for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class Lists
+{
+    protected Lists() {}
+    public static <B> List<List<B>> cartesianProduct(List<? extends B>... p0){ return null; }
+    public static <B> List<List<B>> cartesianProduct(List<? extends List<? extends B>> p0){ return null; }
+    public static <E> ArrayList<E> newArrayList(){ return null; }
+    public static <E> ArrayList<E> newArrayList(E... p0){ return null; }
+    public static <E> ArrayList<E> newArrayList(Iterable<? extends E> p0){ return null; }
+    public static <E> ArrayList<E> newArrayList(Iterator<? extends E> p0){ return null; }
+    public static <E> ArrayList<E> newArrayListWithCapacity(int p0){ return null; }
+    public static <E> ArrayList<E> newArrayListWithExpectedSize(int p0){ return null; }
+    public static <E> CopyOnWriteArrayList<E> newCopyOnWriteArrayList(){ return null; }
+    public static <E> CopyOnWriteArrayList<E> newCopyOnWriteArrayList(Iterable<? extends E> p0){ return null; }
+    public static <E> LinkedList<E> newLinkedList(){ return null; }
+    public static <E> LinkedList<E> newLinkedList(Iterable<? extends E> p0){ return null; }
+    public static <E> List<E> asList(E p0, E p1, E[] p2){ return null; }
+    public static <E> List<E> asList(E p0, E[] p1){ return null; }
+    public static <F, T> List<T> transform(List<F> p0, Function<? super F, ? extends T> p1){ return null; }
+    public static <T> List<List<T>> partition(List<T> p0, int p1){ return null; }
+    public static <T> List<T> reverse(List<T> p0){ return null; }
+    public static ImmutableList<Character> charactersOf(String p0){ return null; }
+    public static List<Character> charactersOf(CharSequence p0){ return null; }
+    static <E> List<E> subListImpl(List<E> p0, int p1, int p2){ return null; }
+    static <E> ListIterator<E> listIteratorImpl(List<E> p0, int p1){ return null; }
+    static <E> boolean addAllImpl(List<E> p0, int p1, Iterable<? extends E> p2){ return false; }
+    static <T> List<T> cast(Iterable<T> p0){ return null; }
+    static boolean equalsImpl(List<? extends Object> p0, Object p1){ return false; }
+    static int computeArrayListCapacity(int p0){ return 0; }
+    static int hashCodeImpl(List<? extends Object> p0){ return 0; }
+    static int indexOfImpl(List<? extends Object> p0, Object p1){ return 0; }
+    static int lastIndexOfImpl(List<? extends Object> p0, Object p1){ return 0; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/MapDifference.java

@@ -0,0 +1,23 @@
+// Generated automatically from com.google.common.collect.MapDifference for testing purposes
+
+package com.google.common.collect;
+
+import java.util.Map;
+
+public interface MapDifference<K, V>
+{
+    Map<K, MapDifference.ValueDifference<V>> entriesDiffering();
+    Map<K, V> entriesInCommon();
+    Map<K, V> entriesOnlyOnLeft();
+    Map<K, V> entriesOnlyOnRight();
+    boolean areEqual();
+    boolean equals(Object p0);
+    int hashCode();
+    static public interface ValueDifference<V>
+    {
+        V leftValue();
+        V rightValue();
+        boolean equals(Object p0);
+        int hashCode();
+    }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Maps.java

@@ -0,0 +1,136 @@
+// Generated automatically from com.google.common.collect.Multimaps for testing purposes, and manually adjusted.
+
+package com.google.common.collect;
+
+import com.google.common.base.Converter;
+import com.google.common.base.Equivalence;
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.Range;
+import com.google.common.collect.SortedMapDifference;
+import com.google.common.collect.UnmodifiableIterator;
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.NavigableSet;
+import java.util.Properties;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.Spliterator;
+import java.util.TreeMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.stream.Collector;
+
+public class Maps
+{
+    protected Maps() {}
+    abstract static class IteratorBasedAbstractMap<K, V> extends AbstractMap<K, V>
+    {
+        IteratorBasedAbstractMap(){}
+        Spliterator<Map.Entry<K, V>> entrySpliterator(){ return null; }
+        abstract Iterator<Map.Entry<K, V>> entryIterator();
+        public Set<Map.Entry<K, V>> entrySet(){ return null; }
+        public abstract int size();
+        public void clear(){}
+        void forEachEntry(Consumer<? super Map.Entry<K, V>> p0){}
+    }
+    public static <A, B> Converter<A, B> asConverter(BiMap<A, B> p0){ return null; }
+    public static <C, K extends C, V> TreeMap<K, V> newTreeMap(Comparator<C> p0){ return null; }
+    public static <K extends Comparable, V> TreeMap<K, V> newTreeMap(){ return null; }
+    public static <K extends Comparable<? super K>, V> NavigableMap<K, V> subMap(NavigableMap<K, V> p0, Range<K> p1){ return null; }
+    public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(Class<K> p0){ return null; }
+    public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(Map<K, ? extends V> p0){ return null; }
+    public static <K extends Enum<K>, V> ImmutableMap<K, V> immutableEnumMap(Map<K, ? extends V> p0){ return null; }
+    public static <K, V1, V2> Map<K, V2> transformEntries(Map<K, V1> p0, Maps.EntryTransformer<? super K, ? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> Map<K, V2> transformValues(Map<K, V1> p0, Function<? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> NavigableMap<K, V2> transformEntries(NavigableMap<K, V1> p0, Maps.EntryTransformer<? super K, ? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> NavigableMap<K, V2> transformValues(NavigableMap<K, V1> p0, Function<? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> SortedMap<K, V2> transformEntries(SortedMap<K, V1> p0, Maps.EntryTransformer<? super K, ? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> SortedMap<K, V2> transformValues(SortedMap<K, V1> p0, Function<? super V1, V2> p1){ return null; }
+    public static <K, V> BiMap<K, V> filterEntries(BiMap<K, V> p0, Predicate<? super Map.Entry<K, V>> p1){ return null; }
+    public static <K, V> BiMap<K, V> filterKeys(BiMap<K, V> p0, Predicate<? super K> p1){ return null; }
+    public static <K, V> BiMap<K, V> filterValues(BiMap<K, V> p0, Predicate<? super V> p1){ return null; }
+    public static <K, V> BiMap<K, V> synchronizedBiMap(BiMap<K, V> p0){ return null; }
+    public static <K, V> BiMap<K, V> unmodifiableBiMap(BiMap<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> ConcurrentMap<K, V> newConcurrentMap(){ return null; }
+    public static <K, V> HashMap<K, V> newHashMap(){ return null; }
+    public static <K, V> HashMap<K, V> newHashMap(Map<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> HashMap<K, V> newHashMapWithExpectedSize(int p0){ return null; }
+    public static <K, V> IdentityHashMap<K, V> newIdentityHashMap(){ return null; }
+    public static <K, V> ImmutableMap<K, V> toMap(Iterable<K> p0, Function<? super K, V> p1){ return null; }
+    public static <K, V> ImmutableMap<K, V> toMap(Iterator<K> p0, Function<? super K, V> p1){ return null; }
+    public static <K, V> ImmutableMap<K, V> uniqueIndex(Iterable<V> p0, Function<? super V, K> p1){ return null; }
+    public static <K, V> ImmutableMap<K, V> uniqueIndex(Iterator<V> p0, Function<? super V, K> p1){ return null; }
+    public static <K, V> LinkedHashMap<K, V> newLinkedHashMap(){ return null; }
+    public static <K, V> LinkedHashMap<K, V> newLinkedHashMap(Map<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> LinkedHashMap<K, V> newLinkedHashMapWithExpectedSize(int p0){ return null; }
+    public static <K, V> Map.Entry<K, V> immutableEntry(K p0, V p1){ return null; }
+    public static <K, V> Map<K, V> asMap(Set<K> p0, Function<? super K, V> p1){ return null; }
+    public static <K, V> Map<K, V> filterEntries(Map<K, V> p0, Predicate<? super Map.Entry<K, V>> p1){ return null; }
+    public static <K, V> Map<K, V> filterKeys(Map<K, V> p0, Predicate<? super K> p1){ return null; }
+    public static <K, V> Map<K, V> filterValues(Map<K, V> p0, Predicate<? super V> p1){ return null; }
+    public static <K, V> MapDifference<K, V> difference(Map<? extends K, ? extends V> p0, Map<? extends K, ? extends V> p1){ return null; }
+    public static <K, V> MapDifference<K, V> difference(Map<? extends K, ? extends V> p0, Map<? extends K, ? extends V> p1, Equivalence<? super V> p2){ return null; }
+    public static <K, V> NavigableMap<K, V> asMap(NavigableSet<K> p0, Function<? super K, V> p1){ return null; }
+    public static <K, V> NavigableMap<K, V> filterEntries(NavigableMap<K, V> p0, Predicate<? super Map.Entry<K, V>> p1){ return null; }
+    public static <K, V> NavigableMap<K, V> filterKeys(NavigableMap<K, V> p0, Predicate<? super K> p1){ return null; }
+    public static <K, V> NavigableMap<K, V> filterValues(NavigableMap<K, V> p0, Predicate<? super V> p1){ return null; }
+    public static <K, V> NavigableMap<K, V> synchronizedNavigableMap(NavigableMap<K, V> p0){ return null; }
+    public static <K, V> NavigableMap<K, V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> p0){ return null; }
+    public static <K, V> SortedMap<K, V> asMap(SortedSet<K> p0, Function<? super K, V> p1){ return null; }
+    public static <K, V> SortedMap<K, V> filterEntries(SortedMap<K, V> p0, Predicate<? super Map.Entry<K, V>> p1){ return null; }
+    public static <K, V> SortedMap<K, V> filterKeys(SortedMap<K, V> p0, Predicate<? super K> p1){ return null; }
+    public static <K, V> SortedMap<K, V> filterValues(SortedMap<K, V> p0, Predicate<? super V> p1){ return null; }
+    public static <K, V> SortedMapDifference<K, V> difference(SortedMap<K, ? extends V> p0, Map<? extends K, ? extends V> p1){ return null; }
+    public static <K, V> TreeMap<K, V> newTreeMap(SortedMap<K, ? extends V> p0){ return null; }
+    public static <T, K extends Enum<K>, V> Collector<T, ? extends Object, ImmutableMap<K, V>> toImmutableEnumMap(Function<? super T, ? extends K> p0, Function<? super T, ? extends V> p1){ return null; }
+    public static <T, K extends Enum<K>, V> Collector<T, ? extends Object, ImmutableMap<K, V>> toImmutableEnumMap(Function<? super T, ? extends K> p0, Function<? super T, ? extends V> p1, BinaryOperator<V> p2){ return null; }
+    public static ImmutableMap<String, String> fromProperties(Properties p0){ return null; }
+    static <E> Comparator<? super E> orNaturalOrder(Comparator<? super E> p0){ return null; }
+    static <E> ImmutableMap<E, Integer> indexMap(Collection<E> p0){ return null; }
+    static <K, V1, V2> Function<Map.Entry<K, V1>, Map.Entry<K, V2>> asEntryToEntryFunction(Maps.EntryTransformer<? super K, ? super V1, V2> p0){ return null; }
+    static <K, V1, V2> Function<Map.Entry<K, V1>, V2> asEntryToValueFunction(Maps.EntryTransformer<? super K, ? super V1, V2> p0){ return null; }
+    static <K, V1, V2> Function<V1, V2> asValueToValueFunction(Maps.EntryTransformer<? super K, V1, V2> p0, K p1){ return null; }
+    static <K, V1, V2> Maps.EntryTransformer<K, V1, V2> asEntryTransformer(Function<? super V1, V2> p0){ return null; }
+    static <K, V> Iterator<K> keyIterator(Iterator<Map.Entry<K, V>> p0){ return null; }
+    static <K, V> Iterator<Map.Entry<K, V>> asMapEntryIterator(Set<K> p0, Function<? super K, V> p1){ return null; }
+    static <K, V> Iterator<V> valueIterator(Iterator<Map.Entry<K, V>> p0){ return null; }
+    static <K, V> Map.Entry<K, V> unmodifiableEntry(Map.Entry<? extends K, ? extends V> p0){ return null; }
+    static <K, V> Set<Map.Entry<K, V>> unmodifiableEntrySet(Set<Map.Entry<K, V>> p0){ return null; }
+    static <K, V> UnmodifiableIterator<Map.Entry<K, V>> unmodifiableEntryIterator(Iterator<Map.Entry<K, V>> p0){ return null; }
+    static <K, V> boolean containsEntryImpl(Collection<Map.Entry<K, V>> p0, Object p1){ return false; }
+    static <K, V> boolean removeEntryImpl(Collection<Map.Entry<K, V>> p0, Object p1){ return false; }
+    static <K, V> void putAllImpl(Map<K, V> p0, Map<? extends K, ? extends V> p1){}
+    static <K> Function<Map.Entry<K, ? extends Object>, K> keyFunction(){ return null; }
+    static <K> K keyOrNull(Map.Entry<K, ? extends Object> p0){ return null; }
+    static <K> Predicate<Map.Entry<K, ? extends Object>> keyPredicateOnEntries(Predicate<? super K> p0){ return null; }
+    static <V2, K, V1> Map.Entry<K, V2> transformEntry(Maps.EntryTransformer<? super K, ? super V1, V2> p0, Map.Entry<K, V1> p1){ return null; }
+    static <V> Function<Map.Entry<? extends Object, V>, V> valueFunction(){ return null; }
+    static <V> Predicate<Map.Entry<? extends Object, V>> valuePredicateOnEntries(Predicate<? super V> p0){ return null; }
+    static <V> V safeGet(Map<? extends Object, V> p0, Object p1){ return null; }
+    static <V> V safeRemove(Map<? extends Object, V> p0, Object p1){ return null; }
+    static <V> V valueOrNull(Map.Entry<? extends Object, V> p0){ return null; }
+    static String toStringImpl(Map<? extends Object, ? extends Object> p0){ return null; }
+    static boolean containsKeyImpl(Map<? extends Object, ? extends Object> p0, Object p1){ return false; }
+    static boolean containsValueImpl(Map<? extends Object, ? extends Object> p0, Object p1){ return false; }
+    static boolean equalsImpl(Map<? extends Object, ? extends Object> p0, Object p1){ return false; }
+    static boolean safeContainsKey(Map<? extends Object, ? extends Object> p0, Object p1){ return false; }
+    static int capacity(int p0){ return 0; }
+    static public interface EntryTransformer<K, V1, V2>
+    {
+        V2 transformEntry(K p0, V1 p1);
+    }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Multimaps.java

@@ -0,0 +1,65 @@
+// Generated automatically from com.google.common.collect.Multimaps for testing purposes, and manually adjusted.
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.SetMultimap;
+import com.google.common.collect.SortedSetMultimap;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.stream.Collector;
+import java.util.stream.Stream;
+
+public class Multimaps
+{
+    protected Multimaps() {}
+    public static <K, V, M extends Multimap<K, V>> M invertFrom(Multimap<? extends V, ? extends K> p0, M p1){ return null; }
+    public static <K, V1, V2> ListMultimap<K, V2> transformEntries(ListMultimap<K, V1> p0, Maps.EntryTransformer<? super K, ? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> ListMultimap<K, V2> transformValues(ListMultimap<K, V1> p0, Function<? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> Multimap<K, V2> transformEntries(Multimap<K, V1> p0, Maps.EntryTransformer<? super K, ? super V1, V2> p1){ return null; }
+    public static <K, V1, V2> Multimap<K, V2> transformValues(Multimap<K, V1> p0, Function<? super V1, V2> p1){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> index(Iterable<V> p0, Function<? super V, K> p1){ return null; }
+    public static <K, V> ImmutableListMultimap<K, V> index(Iterator<V> p0, Function<? super V, K> p1){ return null; }
+    public static <K, V> ListMultimap<K, V> filterKeys(ListMultimap<K, V> p0, Predicate<? super K> p1){ return null; }
+    public static <K, V> ListMultimap<K, V> newListMultimap(Map<K, Collection<V>> p0, Supplier<? extends List<V>> p1){ return null; }
+    public static <K, V> ListMultimap<K, V> synchronizedListMultimap(ListMultimap<K, V> p0){ return null; }
+    public static <K, V> ListMultimap<K, V> unmodifiableListMultimap(ImmutableListMultimap<K, V> p0){ return null; }
+    public static <K, V> ListMultimap<K, V> unmodifiableListMultimap(ListMultimap<K, V> p0){ return null; }
+    public static <K, V> Map<K, Collection<V>> asMap(Multimap<K, V> p0){ return null; }
+    public static <K, V> Map<K, List<V>> asMap(ListMultimap<K, V> p0){ return null; }
+    public static <K, V> Map<K, Set<V>> asMap(SetMultimap<K, V> p0){ return null; }
+    public static <K, V> Map<K, SortedSet<V>> asMap(SortedSetMultimap<K, V> p0){ return null; }
+    public static <K, V> Multimap<K, V> filterEntries(Multimap<K, V> p0, Predicate<? super Map.Entry<K, V>> p1){ return null; }
+    public static <K, V> Multimap<K, V> filterKeys(Multimap<K, V> p0, Predicate<? super K> p1){ return null; }
+    public static <K, V> Multimap<K, V> filterValues(Multimap<K, V> p0, Predicate<? super V> p1){ return null; }
+    public static <K, V> Multimap<K, V> newMultimap(Map<K, Collection<V>> p0, Supplier<? extends Collection<V>> p1){ return null; }
+    public static <K, V> Multimap<K, V> synchronizedMultimap(Multimap<K, V> p0){ return null; }
+    public static <K, V> Multimap<K, V> unmodifiableMultimap(ImmutableMultimap<K, V> p0){ return null; }
+    public static <K, V> Multimap<K, V> unmodifiableMultimap(Multimap<K, V> p0){ return null; }
+    public static <K, V> SetMultimap<K, V> filterEntries(SetMultimap<K, V> p0, Predicate<? super Map.Entry<K, V>> p1){ return null; }
+    public static <K, V> SetMultimap<K, V> filterKeys(SetMultimap<K, V> p0, Predicate<? super K> p1){ return null; }
+    public static <K, V> SetMultimap<K, V> filterValues(SetMultimap<K, V> p0, Predicate<? super V> p1){ return null; }
+    public static <K, V> SetMultimap<K, V> forMap(Map<K, V> p0){ return null; }
+    public static <K, V> SetMultimap<K, V> newSetMultimap(Map<K, Collection<V>> p0, Supplier<? extends Set<V>> p1){ return null; }
+    public static <K, V> SetMultimap<K, V> synchronizedSetMultimap(SetMultimap<K, V> p0){ return null; }
+    public static <K, V> SetMultimap<K, V> unmodifiableSetMultimap(ImmutableSetMultimap<K, V> p0){ return null; }
+    public static <K, V> SetMultimap<K, V> unmodifiableSetMultimap(SetMultimap<K, V> p0){ return null; }
+    public static <K, V> SortedSetMultimap<K, V> newSortedSetMultimap(Map<K, Collection<V>> p0, Supplier<? extends SortedSet<V>> p1){ return null; }
+    public static <K, V> SortedSetMultimap<K, V> synchronizedSortedSetMultimap(SortedSetMultimap<K, V> p0){ return null; }
+    public static <K, V> SortedSetMultimap<K, V> unmodifiableSortedSetMultimap(SortedSetMultimap<K, V> p0){ return null; }
+    public static <T, K, V, M extends Multimap<K, V>> Collector<T, ? extends Object, M> flatteningToMultimap(Function<? super T, ? extends K> p0, Function<? super T, ? extends Stream<? extends V>> p1, Supplier<M> p2){ return null; }
+    public static <T, K, V, M extends Multimap<K, V>> Collector<T, ? extends Object, M> toMultimap(Function<? super T, ? extends K> p0, Function<? super T, ? extends V> p1, Supplier<M> p2){ return null; }
+    static boolean equalsImpl(Multimap<? extends Object, ? extends Object> p0, Object p1){ return false; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Multisets.java

@@ -0,0 +1,47 @@
+// Generated automatically from com.google.common.collect.Multisets for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.SortedMultiset;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Spliterator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.function.ToIntFunction;
+import java.util.stream.Collector;
+
+public class Multisets
+{
+    protected Multisets() {}
+    public static <E> ImmutableMultiset<E> copyHighestCountFirst(Multiset<E> p0){ return null; }
+    public static <E> Multiset.Entry<E> immutableEntry(E p0, int p1){ return null; }
+    public static <E> Multiset<E> difference(Multiset<E> p0, Multiset<? extends Object> p1){ return null; }
+    public static <E> Multiset<E> filter(Multiset<E> p0, Predicate<? super E> p1){ return null; }
+    public static <E> Multiset<E> intersection(Multiset<E> p0, Multiset<? extends Object> p1){ return null; }
+    public static <E> Multiset<E> sum(Multiset<? extends E> p0, Multiset<? extends E> p1){ return null; }
+    public static <E> Multiset<E> union(Multiset<? extends E> p0, Multiset<? extends E> p1){ return null; }
+    public static <E> Multiset<E> unmodifiableMultiset(ImmutableMultiset<E> p0){ return null; }
+    public static <E> Multiset<E> unmodifiableMultiset(Multiset<? extends E> p0){ return null; }
+    public static <E> SortedMultiset<E> unmodifiableSortedMultiset(SortedMultiset<E> p0){ return null; }
+    public static <T, E, M extends Multiset<E>> Collector<T, ? extends Object, M> toMultiset(Function<? super T, E> p0, ToIntFunction<? super T> p1, Supplier<M> p2){ return null; }
+    public static boolean containsOccurrences(Multiset<? extends Object> p0, Multiset<? extends Object> p1){ return false; }
+    public static boolean removeOccurrences(Multiset<? extends Object> p0, Iterable<? extends Object> p1){ return false; }
+    public static boolean removeOccurrences(Multiset<? extends Object> p0, Multiset<? extends Object> p1){ return false; }
+    public static boolean retainOccurrences(Multiset<? extends Object> p0, Multiset<? extends Object> p1){ return false; }
+    static <E> Iterator<E> elementIterator(Iterator<Multiset.Entry<E>> p0){ return null; }
+    static <E> Iterator<E> iteratorImpl(Multiset<E> p0){ return null; }
+    static <E> Spliterator<E> spliteratorImpl(Multiset<E> p0){ return null; }
+    static <E> boolean addAllImpl(Multiset<E> p0, Collection<? extends E> p1){ return false; }
+    static <E> boolean setCountImpl(Multiset<E> p0, E p1, int p2, int p3){ return false; }
+    static <E> int setCountImpl(Multiset<E> p0, E p1, int p2){ return 0; }
+    static <T> Multiset<T> cast(Iterable<T> p0){ return null; }
+    static boolean equalsImpl(Multiset<? extends Object> p0, Object p1){ return false; }
+    static boolean removeAllImpl(Multiset<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    static boolean retainAllImpl(Multiset<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    static int inferDistinctElements(Iterable<? extends Object> p0){ return 0; }
+    static int linearTimeSizeImpl(Multiset<? extends Object> p0){ return 0; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/MutableClassToInstanceMap.java

@@ -0,0 +1,22 @@
+// Generated automatically from com.google.common.collect.MutableClassToInstanceMap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ClassToInstanceMap;
+import com.google.common.collect.ForwardingMap;
+import java.io.Serializable;
+import java.util.Map;
+import java.util.Set;
+
+public class MutableClassToInstanceMap<B> extends ForwardingMap<Class<? extends B>, B> implements ClassToInstanceMap<B>, Serializable
+{
+    protected MutableClassToInstanceMap() {}
+    protected Map<Class<? extends B>, B> delegate(){ return null; }
+    public <T extends B> T getInstance(Class<T> p0){ return null; }
+    public <T extends B> T putInstance(Class<T> p0, T p1){ return null; }
+    public B put(Class<? extends B> p0, B p1){ return null; }
+    public Set<Map.Entry<Class<? extends B>, B>> entrySet(){ return null; }
+    public static <B> MutableClassToInstanceMap<B> create(){ return null; }
+    public static <B> MutableClassToInstanceMap<B> create(Map<Class<? extends B>, B> p0){ return null; }
+    public void putAll(Map<? extends Class<? extends B>, ? extends B> p0){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Ordering.java

@@ -0,0 +1,51 @@
+// Generated automatically from com.google.common.collect.Ordering for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.collect.ImmutableList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+abstract public class Ordering<T> implements Comparator<T>
+{
+    <T2 extends T> Ordering<Map.Entry<T2, ? extends Object>> onKeys(){ return null; }
+    protected Ordering(){}
+    public <E extends T> E max(E p0, E p1){ return null; }
+    public <E extends T> E max(E p0, E p1, E p2, E... p3){ return null; }
+    public <E extends T> E max(Iterable<E> p0){ return null; }
+    public <E extends T> E max(Iterator<E> p0){ return null; }
+    public <E extends T> E min(E p0, E p1){ return null; }
+    public <E extends T> E min(E p0, E p1, E p2, E... p3){ return null; }
+    public <E extends T> E min(Iterable<E> p0){ return null; }
+    public <E extends T> E min(Iterator<E> p0){ return null; }
+    public <E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> p0){ return null; }
+    public <E extends T> List<E> greatestOf(Iterable<E> p0, int p1){ return null; }
+    public <E extends T> List<E> greatestOf(Iterator<E> p0, int p1){ return null; }
+    public <E extends T> List<E> leastOf(Iterable<E> p0, int p1){ return null; }
+    public <E extends T> List<E> leastOf(Iterator<E> p0, int p1){ return null; }
+    public <E extends T> List<E> sortedCopy(Iterable<E> p0){ return null; }
+    public <F> Ordering<F> onResultOf(Function<F, ? extends T> p0){ return null; }
+    public <S extends T> Ordering<Iterable<S>> lexicographical(){ return null; }
+    public <S extends T> Ordering<S> nullsFirst(){ return null; }
+    public <S extends T> Ordering<S> nullsLast(){ return null; }
+    public <S extends T> Ordering<S> reverse(){ return null; }
+    public <U extends T> Ordering<U> compound(Comparator<? super U> p0){ return null; }
+    public abstract int compare(T p0, T p1);
+    public boolean isOrdered(Iterable<? extends T> p0){ return false; }
+    public boolean isStrictlyOrdered(Iterable<? extends T> p0){ return false; }
+    public int binarySearch(List<? extends T> p0, T p1){ return 0; }
+    public static <C extends Comparable> Ordering<C> natural(){ return null; }
+    public static <T> Ordering<T> compound(Iterable<? extends Comparator<? super T>> p0){ return null; }
+    public static <T> Ordering<T> explicit(List<T> p0){ return null; }
+    public static <T> Ordering<T> explicit(T p0, T... p1){ return null; }
+    public static <T> Ordering<T> from(Comparator<T> p0){ return null; }
+    public static <T> Ordering<T> from(Ordering<T> p0){ return null; }
+    public static Ordering<Object> allEqual(){ return null; }
+    public static Ordering<Object> arbitrary(){ return null; }
+    public static Ordering<Object> usingToString(){ return null; }
+    static int LEFT_IS_GREATER = 0;
+    static int RIGHT_IS_GREATER = 0;
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/PeekingIterator.java

@@ -0,0 +1,12 @@
+// Generated automatically from com.google.common.collect.PeekingIterator for testing purposes
+
+package com.google.common.collect;
+
+import java.util.Iterator;
+
+public interface PeekingIterator<E> extends Iterator<E>
+{
+    E next();
+    E peek();
+    void remove();
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Queues.java

@@ -0,0 +1,45 @@
+// Generated automatically from com.google.common.collect.Queues for testing purposes
+
+package com.google.common.collect;
+
+import java.time.Duration;
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.TimeUnit;
+
+public class Queues
+{
+    protected Queues() {}
+    public static <E extends Comparable> PriorityBlockingQueue<E> newPriorityBlockingQueue(){ return null; }
+    public static <E extends Comparable> PriorityBlockingQueue<E> newPriorityBlockingQueue(Iterable<? extends E> p0){ return null; }
+    public static <E extends Comparable> PriorityQueue<E> newPriorityQueue(){ return null; }
+    public static <E extends Comparable> PriorityQueue<E> newPriorityQueue(Iterable<? extends E> p0){ return null; }
+    public static <E> ArrayBlockingQueue<E> newArrayBlockingQueue(int p0){ return null; }
+    public static <E> ArrayDeque<E> newArrayDeque(){ return null; }
+    public static <E> ArrayDeque<E> newArrayDeque(Iterable<? extends E> p0){ return null; }
+    public static <E> ConcurrentLinkedQueue<E> newConcurrentLinkedQueue(){ return null; }
+    public static <E> ConcurrentLinkedQueue<E> newConcurrentLinkedQueue(Iterable<? extends E> p0){ return null; }
+    public static <E> Deque<E> synchronizedDeque(Deque<E> p0){ return null; }
+    public static <E> LinkedBlockingDeque<E> newLinkedBlockingDeque(){ return null; }
+    public static <E> LinkedBlockingDeque<E> newLinkedBlockingDeque(Iterable<? extends E> p0){ return null; }
+    public static <E> LinkedBlockingDeque<E> newLinkedBlockingDeque(int p0){ return null; }
+    public static <E> LinkedBlockingQueue<E> newLinkedBlockingQueue(){ return null; }
+    public static <E> LinkedBlockingQueue<E> newLinkedBlockingQueue(Iterable<? extends E> p0){ return null; }
+    public static <E> LinkedBlockingQueue<E> newLinkedBlockingQueue(int p0){ return null; }
+    public static <E> Queue<E> synchronizedQueue(Queue<E> p0){ return null; }
+    public static <E> SynchronousQueue<E> newSynchronousQueue(){ return null; }
+    public static <E> int drain(BlockingQueue<E> p0, Collection<? super E> p1, int p2, Duration p3){ return 0; }
+    public static <E> int drain(BlockingQueue<E> p0, Collection<? super E> p1, int p2, long p3, TimeUnit p4){ return 0; }
+    public static <E> int drainUninterruptibly(BlockingQueue<E> p0, Collection<? super E> p1, int p2, Duration p3){ return 0; }
+    public static <E> int drainUninterruptibly(BlockingQueue<E> p0, Collection<? super E> p1, int p2, long p3, TimeUnit p4){ return 0; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Range.java

@@ -0,0 +1,58 @@
+// Generated automatically from com.google.common.collect.Range for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import com.google.common.collect.BoundType;
+import com.google.common.collect.Cut;
+import com.google.common.collect.DiscreteDomain;
+import com.google.common.collect.Ordering;
+import com.google.common.collect.RangeGwtSerializationDependencies;
+import java.io.Serializable;
+
+public class Range<C extends Comparable> extends RangeGwtSerializationDependencies implements Predicate<C>, Serializable
+{
+    protected Range() {}
+    Object readResolve(){ return null; }
+    final Cut<C> lowerBound = null;
+    final Cut<C> upperBound = null;
+    public BoundType lowerBoundType(){ return null; }
+    public BoundType upperBoundType(){ return null; }
+    public C lowerEndpoint(){ return null; }
+    public C upperEndpoint(){ return null; }
+    public Range<C> canonical(DiscreteDomain<C> p0){ return null; }
+    public Range<C> gap(Range<C> p0){ return null; }
+    public Range<C> intersection(Range<C> p0){ return null; }
+    public Range<C> span(Range<C> p0){ return null; }
+    public String toString(){ return null; }
+    public boolean apply(C p0){ return false; }
+    public boolean contains(C p0){ return false; }
+    public boolean containsAll(Iterable<? extends C> p0){ return false; }
+    public boolean encloses(Range<C> p0){ return false; }
+    public boolean equals(Object p0){ return false; }
+    public boolean hasLowerBound(){ return false; }
+    public boolean hasUpperBound(){ return false; }
+    public boolean isConnected(Range<C> p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public int hashCode(){ return 0; }
+    public static <C extends Comparable<? extends Object>> Range<C> all(){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> atLeast(C p0){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> atMost(C p0){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> closed(C p0, C p1){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> closedOpen(C p0, C p1){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> downTo(C p0, BoundType p1){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> encloseAll(Iterable<C> p0){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> greaterThan(C p0){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> lessThan(C p0){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> open(C p0, C p1){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> openClosed(C p0, C p1){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> range(C p0, BoundType p1, C p2, BoundType p3){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> singleton(C p0){ return null; }
+    public static <C extends Comparable<? extends Object>> Range<C> upTo(C p0, BoundType p1){ return null; }
+    static <C extends Comparable<? extends Object>> Function<Range<C>, Cut<C>> lowerBoundFn(){ return null; }
+    static <C extends Comparable<? extends Object>> Function<Range<C>, Cut<C>> upperBoundFn(){ return null; }
+    static <C extends Comparable<? extends Object>> Ordering<Range<C>> rangeLexOrdering(){ return null; }
+    static <C extends Comparable<? extends Object>> Range<C> create(Cut<C> p0, Cut<C> p1){ return null; }
+    static int compareOrThrow(Comparable p0, Comparable p1){ return 0; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/RangeGwtSerializationDependencies.java

@@ -0,0 +1,10 @@
+// Generated automatically from com.google.common.collect.RangeGwtSerializationDependencies for testing purposes
+
+package com.google.common.collect;
+
+import java.io.Serializable;
+
+abstract class RangeGwtSerializationDependencies<C extends Comparable> implements Serializable
+{
+    RangeGwtSerializationDependencies(){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/RegularImmutableSortedSet.java

@@ -0,0 +1,47 @@
+// Generated automatically from com.google.common.collect.RegularImmutableSortedSet for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.collect.UnmodifiableIterator;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+class RegularImmutableSortedSet<E> extends ImmutableSortedSet<E>
+{
+    protected RegularImmutableSortedSet() {}
+    Comparator<Object> unsafeComparator(){ return null; }
+    ImmutableList<E> createAsList(){ return null; }
+    ImmutableSortedSet<E> createDescendingSet(){ return null; }
+    ImmutableSortedSet<E> headSetImpl(E p0, boolean p1){ return null; }
+    ImmutableSortedSet<E> subSetImpl(E p0, boolean p1, E p2, boolean p3){ return null; }
+    ImmutableSortedSet<E> tailSetImpl(E p0, boolean p1){ return null; }
+    Object[] internalArray(){ return null; }
+    RegularImmutableSortedSet(ImmutableList<E> p0, Comparator<? super E> p1){}
+    RegularImmutableSortedSet<E> getSubSet(int p0, int p1){ return null; }
+    boolean isPartialView(){ return false; }
+    int copyIntoArray(Object[] p0, int p1){ return 0; }
+    int headIndex(E p0, boolean p1){ return 0; }
+    int indexOf(Object p0){ return 0; }
+    int internalArrayEnd(){ return 0; }
+    int internalArrayStart(){ return 0; }
+    int tailIndex(E p0, boolean p1){ return 0; }
+    public E ceiling(E p0){ return null; }
+    public E first(){ return null; }
+    public E floor(E p0){ return null; }
+    public E higher(E p0){ return null; }
+    public E last(){ return null; }
+    public E lower(E p0){ return null; }
+    public Spliterator<E> spliterator(){ return null; }
+    public UnmodifiableIterator<E> descendingIterator(){ return null; }
+    public UnmodifiableIterator<E> iterator(){ return null; }
+    public boolean contains(Object p0){ return false; }
+    public boolean containsAll(Collection<? extends Object> p0){ return false; }
+    public boolean equals(Object p0){ return false; }
+    public int size(){ return 0; }
+    public void forEach(Consumer<? super E> p0){}
+    static RegularImmutableSortedSet<Comparable> NATURAL_EMPTY_SET = null;
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/RowSortedTable.java

@@ -0,0 +1,14 @@
+// Generated automatically from com.google.common.collect.RowSortedTable for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.Table;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.SortedSet;
+
+public interface RowSortedTable<R, C, V> extends Table<R, C, V>
+{
+    SortedMap<R, Map<C, V>> rowMap();
+    SortedSet<R> rowKeySet();
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Sets.java

@@ -1,93 +1,83 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Generated automatically from com.google.common.collect.Sets for testing purposes, and manually adjusted.
 
 package com.google.common.collect;
 
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Range;
+import com.google.common.collect.UnmodifiableIterator;
 import java.util.AbstractSet;
 import java.util.Collection;
+import java.util.Comparator;
+import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.NavigableSet;
-import java.util.NoSuchElementException;
 import java.util.Set;
-import java.util.function.Predicate;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.stream.Collector;
 
-public final class Sets {
-  private Sets() {}
-
-  public static <E> HashSet<E> newHashSet() {
-    return null;
-  }
-
-  public static <E> HashSet<E> newHashSet(E... elements) {
-    return null;
-  }
-
-  public static <E> HashSet<E> newHashSet(Iterable<? extends E> elements) {
-    return null;
-  }
-  public abstract static class SetView<E> extends AbstractSet<E> {
-    private SetView() {} 
-  }
-
-  public static <E> SetView<E> union(final Set<? extends E> set1, final Set<? extends E> set2) {
-    return null;
-  }
-
-  public static <E> SetView<E> intersection(final Set<E> set1, final Set<?> set2) {
-    return null;
-  }
-
-  public static <E> SetView<E> difference(final Set<E> set1, final Set<?> set2) {
-    return null;
-  }
-
-  public static <E> SetView<E> symmetricDifference(
-      final Set<? extends E> set1, final Set<? extends E> set2) {
-    return null;
-  }
-
-  public static <E> Set<E> filter(Set<E> unfiltered, Predicate<? super E> predicate) {
-    return null;
-  }
-
-  
-  public static <B> Set<List<B>> cartesianProduct(List<? extends Set<? extends B>> sets) {
-    return null;
-  }
-
-  public static <B> Set<List<B>> cartesianProduct(Set<? extends B>... sets) {
-    return null;
-  }
-
-  public static <E> Set<Set<E>> powerSet(Set<E> set) {
-    return null;
-  }
-
-  public static <E> Set<Set<E>> combinations(Set<E> set, final int size) {
-    return null;
-  }
-
-  public static <E> NavigableSet<E> synchronizedNavigableSet(NavigableSet<E> navigableSet) {
-    return null;
-  }
-
-  public static <K extends Comparable<? super K>> NavigableSet<K> subSet(
-      NavigableSet<K> set, Object range) {
-    return null;
-  }
+public class Sets
+{
+    protected Sets() {}
+    abstract static public class SetView<E> extends AbstractSet<E>
+    {
+        protected SetView() {}
+        public <S extends Set<E>> S copyInto(S p0){ return null; }
+        public ImmutableSet<E> immutableCopy(){ return null; }
+        public abstract UnmodifiableIterator<E> iterator();
+        public final boolean add(E p0){ return false; }
+        public final boolean addAll(Collection<? extends E> p0){ return false; }
+        public final boolean remove(Object p0){ return false; }
+        public final boolean removeAll(Collection<? extends Object> p0){ return false; }
+        public final boolean removeIf(Predicate<? super E> p0){ return false; }
+        public final boolean retainAll(Collection<? extends Object> p0){ return false; }
+        public final void clear(){}
+    }
+    public static <B> Set<List<B>> cartesianProduct(List<? extends Set<? extends B>> p0){ return null; }
+    public static <B> Set<List<B>> cartesianProduct(Set<? extends B>... p0){ return null; }
+    public static <E extends Comparable> TreeSet<E> newTreeSet(){ return null; }
+    public static <E extends Comparable> TreeSet<E> newTreeSet(Iterable<? extends E> p0){ return null; }
+    public static <E extends Enum<E>> Collector<E, ? extends Object, ImmutableSet<E>> toImmutableEnumSet(){ return null; }
+    public static <E extends Enum<E>> EnumSet<E> complementOf(Collection<E> p0){ return null; }
+    public static <E extends Enum<E>> EnumSet<E> complementOf(Collection<E> p0, Class<E> p1){ return null; }
+    public static <E extends Enum<E>> EnumSet<E> newEnumSet(Iterable<E> p0, Class<E> p1){ return null; }
+    public static <E extends Enum<E>> ImmutableSet<E> immutableEnumSet(E p0, E... p1){ return null; }
+    public static <E extends Enum<E>> ImmutableSet<E> immutableEnumSet(Iterable<E> p0){ return null; }
+    public static <E> CopyOnWriteArraySet<E> newCopyOnWriteArraySet(){ return null; }
+    public static <E> CopyOnWriteArraySet<E> newCopyOnWriteArraySet(Iterable<? extends E> p0){ return null; }
+    public static <E> HashSet<E> newHashSet(){ return null; }
+    public static <E> HashSet<E> newHashSet(E... p0){ return null; }
+    public static <E> HashSet<E> newHashSet(Iterable<? extends E> p0){ return null; }
+    public static <E> HashSet<E> newHashSet(Iterator<? extends E> p0){ return null; }
+    public static <E> HashSet<E> newHashSetWithExpectedSize(int p0){ return null; }
+    public static <E> LinkedHashSet<E> newLinkedHashSet(){ return null; }
+    public static <E> LinkedHashSet<E> newLinkedHashSet(Iterable<? extends E> p0){ return null; }
+    public static <E> LinkedHashSet<E> newLinkedHashSetWithExpectedSize(int p0){ return null; }
+    public static <E> NavigableSet<E> filter(NavigableSet<E> p0, Predicate<? super E> p1){ return null; }
+    public static <E> NavigableSet<E> synchronizedNavigableSet(NavigableSet<E> p0){ return null; }
+    public static <E> NavigableSet<E> unmodifiableNavigableSet(NavigableSet<E> p0){ return null; }
+    public static <E> Set<E> filter(Set<E> p0, Predicate<? super E> p1){ return null; }
+    public static <E> Set<E> newConcurrentHashSet(){ return null; }
+    public static <E> Set<E> newConcurrentHashSet(Iterable<? extends E> p0){ return null; }
+    public static <E> Set<E> newIdentityHashSet(){ return null; }
+    public static <E> Set<E> newSetFromMap(Map<E, Boolean> p0){ return null; }
+    public static <E> Set<Set<E>> combinations(Set<E> p0, int p1){ return null; }
+    public static <E> Set<Set<E>> powerSet(Set<E> p0){ return null; }
+    public static <E> Sets.SetView<E> difference(Set<E> p0, Set<? extends Object> p1){ return null; }
+    public static <E> Sets.SetView<E> intersection(Set<E> p0, Set<? extends Object> p1){ return null; }
+    public static <E> Sets.SetView<E> symmetricDifference(Set<? extends E> p0, Set<? extends E> p1){ return null; }
+    public static <E> Sets.SetView<E> union(Set<? extends E> p0, Set<? extends E> p1){ return null; }
+    public static <E> SortedSet<E> filter(SortedSet<E> p0, Predicate<? super E> p1){ return null; }
+    public static <E> TreeSet<E> newTreeSet(Comparator<? super E> p0){ return null; }
+    public static <K extends Comparable<? super K>> NavigableSet<K> subSet(NavigableSet<K> p0, Range<K> p1){ return null; }
+    static boolean equalsImpl(Set<? extends Object> p0, Object p1){ return false; }
+    static boolean removeAllImpl(Set<? extends Object> p0, Collection<? extends Object> p1){ return false; }
+    static boolean removeAllImpl(Set<? extends Object> p0, Iterator<? extends Object> p1){ return false; }
+    static int hashCodeImpl(Set<? extends Object> p0){ return 0; }
 }

java/ql/test/stubs/guava-30.0/com/google/common/collect/SortedIterable.java

@@ -0,0 +1,12 @@
+// Generated automatically from com.google.common.collect.SortedIterable for testing purposes
+
+package com.google.common.collect;
+
+import java.util.Comparator;
+import java.util.Iterator;
+
+interface SortedIterable<T> extends Iterable<T>
+{
+    Comparator<? super T> comparator();
+    Iterator<T> iterator();
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/SortedMapDifference.java

@@ -0,0 +1,14 @@
+// Generated automatically from com.google.common.collect.SortedMapDifference for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.MapDifference;
+import java.util.SortedMap;
+
+public interface SortedMapDifference<K, V> extends MapDifference<K, V>
+{
+    SortedMap<K, MapDifference.ValueDifference<V>> entriesDiffering();
+    SortedMap<K, V> entriesInCommon();
+    SortedMap<K, V> entriesOnlyOnLeft();
+    SortedMap<K, V> entriesOnlyOnRight();
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/SortedMultiset.java

@@ -0,0 +1,28 @@
+// Generated automatically from com.google.common.collect.SortedMultiset for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.BoundType;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.SortedIterable;
+import com.google.common.collect.SortedMultisetBridge;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.NavigableSet;
+import java.util.Set;
+
+public interface SortedMultiset<E> extends SortedIterable<E>, SortedMultisetBridge<E>
+{
+    Comparator<? super E> comparator();
+    Iterator<E> iterator();
+    Multiset.Entry<E> firstEntry();
+    Multiset.Entry<E> lastEntry();
+    Multiset.Entry<E> pollFirstEntry();
+    Multiset.Entry<E> pollLastEntry();
+    NavigableSet<E> elementSet();
+    Set<Multiset.Entry<E>> entrySet();
+    SortedMultiset<E> descendingMultiset();
+    SortedMultiset<E> headMultiset(E p0, BoundType p1);
+    SortedMultiset<E> subMultiset(E p0, BoundType p1, E p2, BoundType p3);
+    SortedMultiset<E> tailMultiset(E p0, BoundType p1);
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/SortedMultisetBridge.java

@@ -0,0 +1,11 @@
+// Generated automatically from com.google.common.collect.SortedMultisetBridge for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.Multiset;
+import java.util.SortedSet;
+
+interface SortedMultisetBridge<E> extends Multiset<E>
+{
+    SortedSet<E> elementSet();
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/SortedSetMultimap.java

@@ -0,0 +1,18 @@
+// Generated automatically from com.google.common.collect.SortedSetMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.SetMultimap;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.SortedSet;
+
+public interface SortedSetMultimap<K, V> extends SetMultimap<K, V>
+{
+    Comparator<? super V> valueComparator();
+    Map<K, Collection<V>> asMap();
+    SortedSet<V> get(K p0);
+    SortedSet<V> removeAll(Object p0);
+    SortedSet<V> replaceValues(K p0, Iterable<? extends V> p1);
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/StandardRowSortedTable.java

@@ -0,0 +1,19 @@
+// Generated automatically from com.google.common.collect.StandardRowSortedTable for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.RowSortedTable;
+import com.google.common.collect.StandardTable;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.SortedSet;
+
+class StandardRowSortedTable<R, C, V> extends StandardTable<R, C, V> implements RowSortedTable<R, C, V>
+{
+    protected StandardRowSortedTable() {}
+    SortedMap<R, Map<C, V>> createRowMap(){ return null; }
+    StandardRowSortedTable(SortedMap<R, Map<C, V>> p0, Supplier<? extends Map<C, V>> p1){}
+    public SortedMap<R, Map<C, V>> rowMap(){ return null; }
+    public SortedSet<R> rowKeySet(){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/StandardTable.java

@@ -0,0 +1,43 @@
+// Generated automatically from com.google.common.collect.StandardTable for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.AbstractTable;
+import com.google.common.collect.Table;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Spliterator;
+
+class StandardTable<R, C, V> extends AbstractTable<R, C, V> implements Serializable
+{
+    protected StandardTable() {}
+    Iterator<C> createColumnKeyIterator(){ return null; }
+    Iterator<Table.Cell<R, C, V>> cellIterator(){ return null; }
+    Map<R, Map<C, V>> createRowMap(){ return null; }
+    Spliterator<Table.Cell<R, C, V>> cellSpliterator(){ return null; }
+    StandardTable(Map<R, Map<C, V>> p0, Supplier<? extends Map<C, V>> p1){}
+    final Map<R, Map<C, V>> backingMap = null;
+    final Supplier<? extends Map<C, V>> factory = null;
+    public Collection<V> values(){ return null; }
+    public Map<C, Map<R, V>> columnMap(){ return null; }
+    public Map<C, V> row(R p0){ return null; }
+    public Map<R, Map<C, V>> rowMap(){ return null; }
+    public Map<R, V> column(C p0){ return null; }
+    public Set<C> columnKeySet(){ return null; }
+    public Set<R> rowKeySet(){ return null; }
+    public Set<Table.Cell<R, C, V>> cellSet(){ return null; }
+    public V get(Object p0, Object p1){ return null; }
+    public V put(R p0, C p1, V p2){ return null; }
+    public V remove(Object p0, Object p1){ return null; }
+    public boolean contains(Object p0, Object p1){ return false; }
+    public boolean containsColumn(Object p0){ return false; }
+    public boolean containsRow(Object p0){ return false; }
+    public boolean containsValue(Object p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public int size(){ return 0; }
+    public void clear(){}
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/Table.java

@@ -1,18 +1,4 @@
-/*
- * Copyright (C) 2008 The Guava Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Generated automatically from com.google.common.collect.Table for testing purposes
 
 package com.google.common.collect;
 
@@ -20,50 +6,35 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
 
-public interface Table<R, C, V> {
-  boolean contains(Object rowKey, Object columnKey);
-
-  boolean containsRow(Object rowKey);
-
-  boolean containsColumn(Object columnKey);
-
-  boolean containsValue(Object value);
-
-  V get(Object rowKey, Object columnKey);
-
-  boolean isEmpty();
-
-  int size();
-
-  void clear();
-
-  V put(R rowKey, C columnKey, V value);
-
-  void putAll(Table<? extends R, ? extends C, ? extends V> table);
-
-  V remove(Object rowKey, Object columnKey);
-
-  Map<C, V> row(R rowKey);
-
-  Map<R, V> column(C columnKey);
-
-  Set<Cell<R, C, V>> cellSet();
-
-  Set<R> rowKeySet();
-
-  Set<C> columnKeySet();
-
-  Collection<V> values();
-
-  Map<R, Map<C, V>> rowMap();
-
-  Map<C, Map<R, V>> columnMap();
-
-  interface Cell<R, C, V> {
-    R getRowKey();
-
-    C getColumnKey();
-
-    V getValue();
-  }
+public interface Table<R, C, V>
+{
+    Collection<V> values();
+    Map<C, Map<R, V>> columnMap();
+    Map<C, V> row(R p0);
+    Map<R, Map<C, V>> rowMap();
+    Map<R, V> column(C p0);
+    Set<C> columnKeySet();
+    Set<R> rowKeySet();
+    Set<Table.Cell<R, C, V>> cellSet();
+    V get(Object p0, Object p1);
+    V put(R p0, C p1, V p2);
+    V remove(Object p0, Object p1);
+    boolean contains(Object p0, Object p1);
+    boolean containsColumn(Object p0);
+    boolean containsRow(Object p0);
+    boolean containsValue(Object p0);
+    boolean equals(Object p0);
+    boolean isEmpty();
+    int hashCode();
+    int size();
+    static public interface Cell<R, C, V>
+    {
+        C getColumnKey();
+        R getRowKey();
+        V getValue();
+        boolean equals(Object p0);
+        int hashCode();
+    }
+    void clear();
+    void putAll(Table<? extends R, ? extends C, ? extends V> p0);
 }

java/ql/test/stubs/guava-30.0/com/google/common/collect/Tables.java

@@ -0,0 +1,26 @@
+// Generated automatically from com.google.common.collect.Tables for testing purposes, and manually adjusted.
+
+package com.google.common.collect;
+
+import com.google.common.base.Function;
+import com.google.common.base.Supplier;
+import com.google.common.collect.RowSortedTable;
+import com.google.common.collect.Table;
+import java.util.Map;
+import java.util.function.BinaryOperator;
+import java.util.stream.Collector;
+
+public class Tables
+{
+    protected Tables() {}
+    public static <R, C, V1, V2> Table<R, C, V2> transformValues(Table<R, C, V1> p0, Function<? super V1, V2> p1){ return null; }
+    public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(RowSortedTable<R, ? extends C, ? extends V> p0){ return null; }
+    public static <R, C, V> Table.Cell<R, C, V> immutableCell(R p0, C p1, V p2){ return null; }
+    public static <R, C, V> Table<C, R, V> transpose(Table<R, C, V> p0){ return null; }
+    public static <R, C, V> Table<R, C, V> newCustomTable(Map<R, Map<C, V>> p0, Supplier<? extends Map<C, V>> p1){ return null; }
+    public static <R, C, V> Table<R, C, V> synchronizedTable(Table<R, C, V> p0){ return null; }
+    public static <R, C, V> Table<R, C, V> unmodifiableTable(Table<? extends R, ? extends C, ? extends V> p0){ return null; }
+    public static <T, R, C, V, I extends Table<R, C, V>> Collector<T, ? extends Object, I> toTable(Function<? super T, ? extends R> p0, Function<? super T, ? extends C> p1, Function<? super T, ? extends V> p2, BinaryOperator<V> p3, Supplier<I> p4){ return null; }
+    public static <T, R, C, V, I extends Table<R, C, V>> Collector<T, ? extends Object, I> toTable(Function<? super T, ? extends R> p0, Function<? super T, ? extends C> p1, Function<? super T, ? extends V> p2, Supplier<I> p3){ return null; }
+    static boolean equalsImpl(Table<? extends Object, ? extends Object, ? extends Object> p0, Object p1){ return false; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/TreeBasedTable.java

@@ -0,0 +1,25 @@
+// Generated automatically from com.google.common.collect.TreeBasedTable for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.StandardRowSortedTable;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.SortedSet;
+
+public class TreeBasedTable<R, C, V> extends StandardRowSortedTable<R, C, V>
+{
+    protected TreeBasedTable() {}
+    Iterator<C> createColumnKeyIterator(){ return null; }
+    TreeBasedTable(Comparator<? super R> p0, Comparator<? super C> p1){}
+    public Comparator<? super C> columnComparator(){ return null; }
+    public Comparator<? super R> rowComparator(){ return null; }
+    public SortedMap<C, V> row(R p0){ return null; }
+    public SortedMap<R, Map<C, V>> rowMap(){ return null; }
+    public SortedSet<R> rowKeySet(){ return null; }
+    public static <R extends Comparable, C extends Comparable, V> TreeBasedTable<R, C, V> create(){ return null; }
+    public static <R, C, V> TreeBasedTable<R, C, V> create(Comparator<? super R> p0, Comparator<? super C> p1){ return null; }
+    public static <R, C, V> TreeBasedTable<R, C, V> create(TreeBasedTable<R, C, ? extends V> p0){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/TreeMultimap.java

@@ -0,0 +1,29 @@
+// Generated automatically from com.google.common.collect.TreeMultimap for testing purposes
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractSortedKeySortedSetMultimap;
+import com.google.common.collect.Multimap;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.NavigableSet;
+import java.util.SortedSet;
+
+public class TreeMultimap<K, V> extends AbstractSortedKeySortedSetMultimap<K, V>
+{
+    protected TreeMultimap() {}
+    Collection<V> createCollection(K p0){ return null; }
+    Map<K, Collection<V>> createAsMap(){ return null; }
+    SortedSet<V> createCollection(){ return null; }
+    TreeMultimap(Comparator<? super K> p0, Comparator<? super V> p1){}
+    public Comparator<? super K> keyComparator(){ return null; }
+    public Comparator<? super V> valueComparator(){ return null; }
+    public NavigableMap<K, Collection<V>> asMap(){ return null; }
+    public NavigableSet<K> keySet(){ return null; }
+    public NavigableSet<V> get(K p0){ return null; }
+    public static <K extends Comparable, V extends Comparable> TreeMultimap<K, V> create(){ return null; }
+    public static <K extends Comparable, V extends Comparable> TreeMultimap<K, V> create(Multimap<? extends K, ? extends V> p0){ return null; }
+    public static <K, V> TreeMultimap<K, V> create(Comparator<? super K> p0, Comparator<? super V> p1){ return null; }
+}

java/ql/test/stubs/guava-30.0/com/google/common/collect/TreeMultiset.java

@@ -0,0 +1,37 @@
+// Generated automatically from com.google.common.collect.TreeMultiset for testing purposes, and manually adjusted.
+
+package com.google.common.collect;
+
+import com.google.common.collect.AbstractSortedMultiset;
+import com.google.common.collect.BoundType;
+import com.google.common.collect.GeneralRange;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.SortedMultiset;
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.function.ObjIntConsumer;
+
+public class TreeMultiset<E> extends AbstractSortedMultiset<E> implements Serializable
+{
+    protected TreeMultiset() {}
+    Iterator<E> elementIterator(){ return null; }
+    Iterator<Multiset.Entry<E>> descendingEntryIterator(){ return null; }
+    Iterator<Multiset.Entry<E>> entryIterator(){ return null; }
+    TreeMultiset(Comparator<? super E> p0){}
+    int distinctElements(){ return 0; }
+    public Iterator<E> iterator(){ return null; }
+    public SortedMultiset<E> headMultiset(E p0, BoundType p1){ return null; }
+    public SortedMultiset<E> tailMultiset(E p0, BoundType p1){ return null; }
+    public boolean setCount(E p0, int p1, int p2){ return false; }
+    public int add(E p0, int p1){ return 0; }
+    public int count(Object p0){ return 0; }
+    public int remove(Object p0, int p1){ return 0; }
+    public int setCount(E p0, int p1){ return 0; }
+    public int size(){ return 0; }
+    public static <E extends Comparable> TreeMultiset<E> create(){ return null; }
+    public static <E extends Comparable> TreeMultiset<E> create(Iterable<? extends E> p0){ return null; }
+    public static <E> TreeMultiset<E> create(Comparator<? super E> p0){ return null; }
+    public void clear(){}
+    public void forEachEntry(ObjIntConsumer<? super E> p0){}
+}