CollectionPerformance.hint

<?
import org.netbeans.modules.java.hints.declarative.APIAccessor;
import com.sun.source.tree.*;
import com.sun.source.tree.Tree.Kind;
import com.sun.source.util.TreePath;
import com.sun.tools.javac.tree.*;
import javax.lang.model.element.ElementKind;
?>

<!description="Refactor to modern Collection APIs and idioms.">

// replace old collections
java.util.Stack =>
java.util.ArrayDeque;;

java.util.Vector =>
java.util.ArrayList;;
/*
java.util.LinkedList =>
java.util.ArrayList;;
*/
java.util.Hashtable =>
java.util.HashMap;;

$modifiers$ java.util.Stack<$g> $name = new java.util.Stack<$g$>(); =>
$modifiers$ java.util.Deque<$g> $name = new java.util.ArrayDeque<$g$>();
;;

/*
$modifiers$ java.util.Stack<$g> $name = $initializer; =>
$modifiers$ java.util.Deque<$g> $name = $initializer;
;;

$modifiers$ java.util.Stack<$g> $name; =>
$modifiers$ java.util.Deque<$g> $name;
;;

new java.util.Stack<$g$>() =>
new java.util.Deque<$g$>()
;;
*/

// maps to Collection interface post refactoring
$stack.empty() :: $stack instanceof java.util.Stack =>
$stack.isEmpty()
;;

// avoid raw type warnings
java.util.Collections.EMPTY_LIST =>
java.util.Collections.emptyList();;

java.util.Collections.EMPTY_SET =>
java.util.Collections.emptySet();;

java.util.Collections.EMPTY_MAP =>
java.util.Collections.emptyMap();;

// more descriptive
java.util.Arrays.asList() =>
java.util.Collections.emptyList();;

// prefer immutable collection for small arrays
// not recommended for large arrays in inner loops due to the null check
// todo: add check for $a not being an array + remove $b
"List.of is more compact for small lists.":
java.util.Arrays.asList($a, $b, $more$) :: !parentMatches("java.util.Collections.unmodifiableList($_)") && sourceVersionGE(9) =>
java.util.List.of($a, $b, $more$);;

// shorter 9+
java.util.Collections.singletonList($a) :: sourceVersionGE(9) =>
java.util.List.of($a);;

java.util.Collections.singleton($a) :: sourceVersionGE(9) =>
java.util.Set.of($a);;

java.util.Collections.singletonMap($k, $v) :: sourceVersionGE(9) =>
java.util.Map.of($k, $v);;

// 9+
java.util.Collections.unmodifiableList(java.util.Arrays.asList($a$)) :: sourceVersionGE(9) =>
java.util.List.of($a$);;

java.util.Collections.unmodifiableList(java.util.List.of($a$)) :: sourceVersionGE(9) =>
java.util.List.of($a$);;

java.util.Collections.unmodifiableSet(java.util.Set.of($a$)) :: sourceVersionGE(9) =>
java.util.Set.of($a$);;

java.util.Collections.unmodifiableSet(new $Set<$T$>(java.util.Arrays.asList($a$))) :: $Set instanceof java.util.Set && sourceVersionGE(9) =>
java.util.Set.of($a$);;

java.util.Collections.unmodifiableSet(new $Set<$T$>(java.util.List.of($a$))) :: $Set instanceof java.util.Set && sourceVersionGE(9) =>
java.util.Set.of($a$);;

"could be replaced with new LinkedHashSet<>().":
java.util.Collections.newSetFromMap(new java.util.LinkedHashMap<$kv$>()) =>
new java.util.LinkedHashSet<>();;

"could be replaced with new LinkedHashSet<>().":
java.util.Collections.newSetFromMap(new java.util.LinkedHashMap<$kv$>($c)) :: $c instanceof int =>
new java.util.LinkedHashSet<>($c);;

"could be replaced with new LinkedHashSet<>().":
java.util.Collections.newSetFromMap(new java.util.LinkedHashMap<$kv$>($c, $f)) :: $c instanceof int && $f instanceof float =>
new java.util.LinkedHashSet<>($c, $f);;

"could be replaced with ConcurrentHashMap.newKeySet().":
java.util.Collections.newSetFromMap(new java.util.concurrent.ConcurrentHashMap<$kv$>()) =>
java.util.concurrent.ConcurrentHashMap.newKeySet();;

"could be replaced with ConcurrentHashMap.newKeySet().":
java.util.Collections.newSetFromMap(new java.util.concurrent.ConcurrentHashMap<$kv$>($c)) :: $c instanceof int =>
java.util.concurrent.ConcurrentHashMap.newKeySet($c);;

// todo: needs read only check
"could be potentially replaced with Set.of(..) - if immutable.":
new $Set<$T$>(java.util.Arrays.asList($a, $b, $more$)) :: $Set instanceof java.util.Set && !parentMatches("java.util.Collections.unmodifiableSet($_)") && sourceVersionGE(9) =>
java.util.Set.of($a, $b, $more$)
;;

"could be potentially replaced with Set.of(..) - if immutable.":
new $Set<$T$>(java.util.List.of($a, $b, $more$)) :: $Set instanceof java.util.Set && !parentMatches("java.util.Collections.unmodifiableSet($_)") && sourceVersionGE(9) =>
java.util.Set.of($a, $b, $more$)
;;

// unmodifiable view -> immutable copy; 10+
/*
"unmodifiable view can be potentially replaced with immutable copy.":
java.util.Collections.unmodifiableList($list) :: $list instanceof java.util.List && sourceVersionGE(10) =>
java.util.List.copyOf($list);;

"unmodifiable view can be potentially replaced with immutable copy.":
java.util.Collections.unmodifiableCollection($col) :: $col instanceof java.util.Collection && sourceVersionGE(10) =>
java.util.List.copyOf($col);;

"unmodifiable view can be potentially replaced with immutable copy.":
java.util.Collections.unmodifiableSet($set) :: $set instanceof java.util.Set && sourceVersionGE(10) =>
java.util.Set.copyOf($set);;

"unmodifiable view can be potentially replaced with immutable copy.":
java.util.Collections.unmodifiableMap($map) :: $map instanceof java.util.Map && sourceVersionGE(10) =>
java.util.Map.copyOf($map);;
*/

// prefer list.sort()
// less readable
//java.util.Collections.sort($list) :: $list instanceof java.util.List =>
//$list.sort(null);;

java.util.Collections.sort($list, $comp) :: $list instanceof java.util.List =>
$list.sort($comp);;

// shorter and in super SequencedCollection/Map interface
"can use reversed()":
$set.descendingSet() :: $set instanceof java.util.NavigableSet && sourceVersionGE(21) =>
$set.reversed();;

"can use reversed()":
$map.descendingMap() :: $map instanceof java.util.NavigableMap && sourceVersionGE(21) =>
$map.reversed();;

// more sequenced collection methods
"can use getFirst()":
$list.get(0) :: $list instanceof java.util.List && sourceVersionGE(21) =>
$list.getFirst();;

"can use removeFirst()":
$list.remove(0) :: $list instanceof java.util.List && sourceVersionGE(21) =>
$list.removeFirst();;

"can use addFirst()":
$list.add(0, $elem) :: $list instanceof java.util.List && sourceVersionGE(21) =>
$list.addFirst($elem);;

"can use getLast()":
$list.get($list.size()-1) :: $list instanceof java.util.List && sourceVersionGE(21) =>
$list.getLast();;

"can use removeLast()":
$list.remove($list.size()-1) :: $list instanceof java.util.List && sourceVersionGE(21) =>
$list.removeLast();;

"can use addLast()":
$list.add($list.size()-1, $elem) :: $list instanceof java.util.List && sourceVersionGE(21) =>
$list.addLast($elem);;


// collections have faster bulk add opperations than the sequential loop of Collections.addAll()
java.util.Collections.addAll($col, $array$) :: $col instanceof java.util.Collection =>
$col.addAll(java.util.Arrays.asList($array$));;

// todo $col = new $Col(); doesn't work

// prefer copy constructor over addAll()
"can use copy constructor":
$pre$ $col = new $Col();
$col.addAll($other);
$more$;
:: $Col instanceof java.util.Collection && !containsAny($more$, "$col.addAll($other2)") =>
$pre$ $col = new $Col($other);
$more$;
;;

"can use copy constructor":
$pre$ $col = new $Col($other.size());
$col.addAll($other);
:: $Col instanceof java.util.Collection =>
$pre$ $col = new $Col($other);
;;

"can use copy constructor":
$pre$ $map = new $Map();
$map.putAll($other);
$more$;
:: $Map instanceof java.util.Map && !$Map instanceof java.util.Properties  && !containsAny($more$, "$map.putAll($other2)") =>
$pre$ $map = new $Map($other);
$more$;
;;

"can use copy constructor":
$pre$ $map = new $Map($other.size());
$map.putAll($other);
:: $Map instanceof java.util.Map && !$Map instanceof java.util.Properties =>
$pre$ $map = new $Map($other);
;;

"can use containsKey()":
$map.keySet().contains($key) :: $map instanceof java.util.Map =>
$map.containsKey($key)
;;

"can use containsValue()":
$map.values().contains($value) :: $map instanceof java.util.Map =>
$map.containsValue($value)
;;

"can use removeAll()":
for ($E $e : $col) {
    $other.remove($e);
}
:: $col instanceof java.util.Collection && $other instanceof java.util.Collection =>
$other.removeAll($col);
;;

"can use keySet().removeAll()":
for ($E $e : $col) {
    $map.remove($e);
}
:: $col instanceof java.util.Collection && $map instanceof java.util.Map =>
$map.keySet().removeAll($col);
;;

"can use addAll()":
for ($E $e : $col) {
    $other.add($e);
}
:: $col instanceof java.util.Collection && $other instanceof java.util.Collection && elementKindMatches($other, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE) =>
$other.addAll($col);
;;

"can use putAll()":
for ($K $k : $map.keySet()) {
    $other.add($k, $map.get($k));
}
:: $map instanceof java.util.Map && $other instanceof java.util.Map && elementKindMatches($other, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE) =>
$other.putAll($map);
;;

"can use putAll()":
for ($E $e : $map.entrySet()) {
    $other.add($e.getKey(), $e.getValue());
}
:: $map instanceof java.util.Map && $other instanceof java.util.Map && E instanceof java.util.Map.Entry && elementKindMatches($other, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE) =>
$other.putAll($map);
;;

// avoid inefficient map traversal
for ($K $k : $map.keySet()) {
    $preamble$;
    $V $v = $map.get($k);
    $body$;
} :: $map instanceof java.util.Map && !referencedIn($k, $preamble$)
=>
for ($V $v : $map.values()) {
    $preamble$;
    $body$;
}
:: !referencedIn($k, $body$)
=>
for (java.util.Map.Entry<$K, $V> entry : $map.entrySet()) {
    $preamble$;
    $K $k = entry.getKey();
    $V $v = entry.getValue();
    $body$;
}
:: otherwise
;;

// contains + get in succession
"could be potentially replaced with a single get(key) if the map does not contain null values":
if ($map.containsKey($key)) {
    $preamble$;
    $V $v = $map.get($key);
    $body$;
} :: $map instanceof java.util.Map && !referencedIn($key, $preamble$)
=>
$V $v = $map.get($key);
if ($v != null) {
    $preamble$;
    $body$;
}
;;

// todo: figure out how to get val type
"could be potentially replaced with a single get(key) if the map does not contain null values":
if ($map.containsKey($key)) {
    return $map.get($key);
} :: $map instanceof java.util.Map
=>
Object val = $map.get($key);
if (val != null) {
    return val;
}
;;

// get + remove in succession
if ($map.get($k) == $v) {
    $map.remove($k);
} :: $map instanceof java.util.Map
=>
$map.remove($k, $v);
;;

// contains + remove in succession
if ($col.contains($v)) {
    $col.remove($v);
} :: $col instanceof java.util.Collection
=>
$col.remove($v);
;;

if ($map.containsKey($k)) {
    $map.remove($k);
    $rest$;
} :: $map instanceof java.util.Map
=>
$map.remove($k);
:: isEmpty($rest$)
=>
"could be potentially replaced with a single remove(key) if the map does not contain null values":
if ($map.remove($k) == null) {
    $rest$;
}
:: otherwise
;;

// contains + put
"could be potentially replaced with [compute|put]IfAbsent(key, value) if the map does not contain null values":
if (!$map.containsKey($k)) {
    $map.put($k, $v);
}                                    :: $map instanceof java.util.Map
=>
$map.putIfAbsent($k, $v);            :: elementKindMatches($v, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE, ElementKind.ENUM_CONSTANT)
=>
$map.computeIfAbsent($k, k -> $v);   :: otherwise
;;

"could be replaced with [compute|put]IfAbsent(key, value)":
if ($nullcheck) {
    $map.put($k, $v);
}                                    :: $map instanceof java.util.Map && matchesAny($nullcheck, "$map.get($k) == null", "null == $map.get($k)")
=>
$map.putIfAbsent($k, $v);            :: elementKindMatches($v, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE, ElementKind.ENUM_CONSTANT)
=>
$map.computeIfAbsent($k, k -> $v);   :: otherwise
;;

// add to sub-collection or other values
"could be replaced with [compute|put]IfAbsent($key, k -> $valInit)":
$Val $val = $map.get($key);
if ($nullcheck) {
    $val = $valInit;
    $map.put($key, $val);
}                                                      :: $map instanceof java.util.Map && matchesAny($nullcheck, "$val == null", "null == $val")
=>
$Val $val = $map.putIfAbsent($key, $valInit);          :: elementKindMatches($valInit, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE, ElementKind.ENUM_CONSTANT)
=>
$Val $val = $map.computeIfAbsent($key, k -> $valInit); :: otherwise
;;

// variant 2
"could be replaced with [compute|put]IfAbsent($key, k -> $valInit)":
$Val $val = $map.get($key);
if ($nullcheck) {
    $map.put($key, $val = $valInit);
}                                                      :: $map instanceof java.util.Map && matchesAny($nullcheck, "$val == null", "null == $val")
=>
$Val $val = $map.putIfAbsent($key, $valInit);          :: elementKindMatches($valInit, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE, ElementKind.ENUM_CONSTANT)
=>
$Val $val = $map.computeIfAbsent($key, k -> $valInit); :: otherwise
;;

// variant with return
"could be replaced with computeIfAbsent($key, k -> {$valInit})":
$val = $map.get($key);
if ($nullcheck) {
    return $val;
}
$init$;
$val = $valInit;
$map.put($key, $val);                                  :: $map instanceof java.util.Map && matchesAny($nullcheck, "$val != null", "null != $val")
                                                       && !referencedIn($map, $init$)
=>
$val = $map.computeIfAbsent($key, k -> {$init$; return $valInit;});
;;

"could be replaced with [compute|put]IfAbsent($key, k -> $valInit) to only compute when needed":
$map.putIfAbsent($key, $value)       :: $map instanceof java.util.Map && !elementKindMatches($value, ElementKind.FIELD, ElementKind.PARAMETER, ElementKind.LOCAL_VARIABLE, ElementKind.ENUM_CONSTANT)
=>
$map.computeIfAbsent($key, k -> $value)
;;

// complementary inline rules
"could be inlined as putIfAbsent(key, value).method(..)":
$Val $val = $map.putIfAbsent($key, $value);
$val.$method($params$);
$more$                               :: $map instanceof java.util.Map && !referencedIn($val, $more$)
=>
$map.putIfAbsent($key, $value).$method($params$);
$more$
;;

"could be inlined as computeIfAbsent(key, value).method(..)":
$Val $val = $map.computeIfAbsent($key, $value);
$val.$method($params$);
$more$                               :: $map instanceof java.util.Map && !referencedIn($val, $more$)
=>
$map.computeIfAbsent($key, $value).$method($params$);
$more$
;;

// get instead contains (dangerous! values can be null)
/*
$map.get($k) == null :: $map instanceof java.util.Map =>
!$map.containsKey($k)
;;

$map.get($k) != null :: $map instanceof java.util.Map =>
$map.containsKey($k)
;;
*/

// concise map population
for ($O $o : $col) {
    $map.put($key, $value);
} :: $col instanceof java.util.Collection && $map instanceof java.util.Map
=>
$col.forEach($o -> $map.put($key, $value));
;;


// removeIf() 8+
// for .iterator() and .listIterator()
"can use removeIf($condition)":
$Iter<$T> $it = $col.$iterator();
while ($it.hasNext()) {
    $T $t = $it.next();
    if ($condition) {
        $it.remove();
    }
} :: $col instanceof java.util.Collection && $Iter instanceof java.util.Iterator
=>
$col.removeIf($t -> $condition);
;;

"can use removeIf($condition)":
$Iter<$T> $it = $col.$iterator();
while ($it.hasNext()) {
    if ($it.next().$condition($params$)) {
        $it.remove();
    }
} :: $col instanceof java.util.Collection && $Iter instanceof java.util.Iterator
=>
$col.removeIf(e -> e.$condition($params$));
;;

"can use removeIf($condition)":
for ($Iter<$T> $it = $col.$iterator(); $it.hasNext();) {
    $T $t = $it.next();
    if ($condition) {
        $it.remove();
    }
} :: $col instanceof java.util.Collection && $Iter instanceof java.util.Iterator
=>
$col.removeIf($t -> $condition);
;;


"can use forEachRemaining($body)":
while ($it.hasNext()) {
    $T $entry = $it.next();
    $body$;
} :: $it instanceof java.util.Iterator && !referencedIn($it, $body$)
=>
$it.forEachRemaining($entry -> {
    $body$;
});
;;

"can use for-each loop":
$Iter<$T> $it = $iterable.$iterator();
while ($it.hasNext()) {
    $T $entry = $it.next();
    $body$;
} :: $it instanceof java.util.Iterator && $Iter instanceof java.util.Iterator && $iterable instanceof java.lang.Iterable && !referencedIn($it, $body$)
=>
for ($T $entry : $iterable) {
    $body$;
}
;;

"inline iterator variable":
java.util.Iterator<$T> $it = $IT;
$it.forEachRemaining($body$);
$rest$;                          :: !referencedIn($it, $rest$)
=>
$col.forEach($body$);
$rest$;                          :: matchesWithBind($IT, "$col.iterator()") && $col instanceof java.util.Collection
=>
$IT.forEachRemaining($body$);
$rest$;                          :: otherwise
;;

"can use for-each loop over Iterable":
for (java.util.Iterator<$T> $it = $iterable.iterator(); $it.hasNext(); ) {
    $T $v = $it.next();
    $body$;
}
:: $iterable instanceof Iterable && !referencedIn($it, $body$)
=>
for ($T $v : $iterable) {
    $body$;
}
;;

// URLs as keys can caue performance problems
// set + URL
"URLs used as keys in collections can cause performance problems, since equals() and hashCode() trigger blocking domain lookup operations. Try using java.net.URI instead.":
new $SET<java.net.URL>($args$) :: $SET instanceof java.util.Set =>
new $SET<java.net.URI>($args$)
;;

"URLs used as keys in collections can cause performance problems, since equals() and hashCode() trigger blocking domain lookup operations. Try using java.net.URI instead.":
$SET<java.net.URL> $set = $init$; :: $set instanceof java.util.Set =>
$SET<java.net.URI> $set = $init$;
;;

"URLs used as keys in collections can cause performance problems, since equals() and hashCode() trigger blocking domain lookup operations. Try using java.net.URI instead.":
$set.add($key) :: $set instanceof java.util.Set<java.net.URL> && $key instanceof java.net.URL =>
$set.add($key.toURI())
;;

// map + URL
"URLs used as keys in collections can cause performance problems, since equals() and hashCode() trigger blocking domain lookup operations. Try using java.net.URI instead.":
new $MAP<java.net.URL, $V>($args$) :: $MAP instanceof java.util.Map =>
new $MAP<java.net.URI, $V>($args$)
;;

"URLs used as keys in collections can cause performance problems, since equals() and hashCode() trigger blocking domain lookup operations. Try using java.net.URI instead.":
$MAP<java.net.URL, $V> $map = $init$; :: $MAP instanceof java.util.Map =>
$MAP<java.net.URI, $V> $map = $init$;
;;

"URLs used as keys in collections can cause performance problems, since equals() and hashCode() trigger blocking domain lookup operations. Try using java.net.URI instead.":
$map.put($key, $value) :: $map instanceof java.util.Map<java.net.URL, ?> && $key instanceof java.net.URL =>
$map.put($key.toURI(), $value)
;;

// <19
"suboptimal capacity computation":
new $Col<$T$>($cap) :: sourceVersionLE(18) && $cap instanceof int
                    && matchesAny($Col, "java.util.HashMap", "java.util.LinkedHashMap", "java.util.HashSet", "java.util.LinkedHashSet", "java.util.WeakHashMap")
                    && !matchesAny($cap, "(int) Math.ceil($n / 0.75)")
                    && !isIntLiteral($cap)
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(int) Math.ceil($n / 0.75f)")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(int) ($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(int) ($n / $fac) + $one") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "($n * 4 + 2) / 3")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(4 * $n + 2) / 3")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "($n * 4) / 3 + 1")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "($n * 4) / 3")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(4 * $n) / 3 + 1")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(4 * $n) / 3")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "$n * 4 / 3 + 1")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "$n * 4 / 3")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "4 * $n / 3 + 1")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "4 * $n / 3")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(int) (($n * 4L + 2L) / 3L)")
=> new $Col<$T$>((int) Math.ceil($n / 0.75)) :: matchesWithBind($cap, "(int) ((4L * $n + 2L) / 3L)")
=> new $Col<$T$>((int) Math.ceil($cap / 0.75)) :: otherwise
;;

// 19+ Map/Set factory methods
"convert to factory method for creating pre-sized Maps using initial number of entries instead of table capacity.":
new java.util.HashMap<$T$>($cap) :: $cap instanceof int && sourceVersionGE(19)
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(int) Math.ceil($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac) + $one") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "($n * 4 + 2) / 3")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(4 * $n + 2) / 3")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "($n * 4) / 3 + 1")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "($n * 4) / 3")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(4 * $n) / 3 + 1")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(4 * $n) / 3")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "$n * 4 / 3 + 1")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "$n * 4 / 3")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "4 * $n / 3 + 1")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "4 * $n / 3")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(int) (($n * 4L + 2L) / 3L)")
=> java.util.HashMap.newHashMap($n) :: matchesWithBind($cap, "(int) ((4L * $n + 2L) / 3L)")
=> java.util.HashMap.newHashMap($cap) :: otherwise
;;

"convert to factory method for creating pre-sized Maps using initial number of entries instead of table capacity.":
new java.util.LinkedHashMap<$T$>($cap) :: $cap instanceof int && sourceVersionGE(19)
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(int) Math.ceil($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "($n * 4 + 2) / 3")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(4 * $n + 2) / 3")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "($n * 4) / 3 + 1")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "($n * 4) / 3")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(4 * $n) / 3 + 1")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(4 * $n) / 3")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "$n * 4 / 3 + 1")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "$n * 4 / 3")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "4 * $n / 3 + 1")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "4 * $n / 3")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(int) (($n * 4L + 2L) / 3L)")
=> java.util.LinkedHashMap.newLinkedHashMap($n) :: matchesWithBind($cap, "(int) ((4L * $n + 2L) / 3L)")
=> java.util.LinkedHashMap.newLinkedHashMap($cap) :: otherwise
;;

"convert to factory method for creating pre-sized Maps using initial number of entries instead of table capacity.":
new java.util.WeakHashMap<$T$>($cap) :: $cap instanceof int && sourceVersionGE(19)
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(int) Math.ceil($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "($n * 4 + 2) / 3")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(4 * $n + 2) / 3")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "($n * 4) / 3 + 1")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "($n * 4) / 3")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(4 * $n) / 3 + 1")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(4 * $n) / 3")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "$n * 4 / 3 + 1")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "$n * 4 / 3")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "4 * $n / 3 + 1")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "4 * $n / 3")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(int) (($n * 4L + 2L) / 3L)")
=> java.util.WeakHashMap.newWeakHashMap($n) :: matchesWithBind($cap, "(int) ((4L * $n + 2L) / 3L)")
=> java.util.WeakHashMap.newWeakHashMap($cap) :: otherwise
;;

"convert to factory method for creating pre-sized Sets using initial number of entries instead of table capacity.":
new java.util.HashSet<$T$>($cap) :: $cap instanceof int && sourceVersionGE(19)
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(int) Math.ceil($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(int) ($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "($n * 4 + 2) / 3")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(4 * $n + 2) / 3")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "($n * 4) / 3 + 1")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "($n * 4) / 3")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(4 * $n) / 3 + 1")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(4 * $n) / 3")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "$n * 4 / 3 + 1")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "$n * 4 / 3")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "4 * $n / 3 + 1")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "4 * $n / 3")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(int) (($n * 4L + 2L) / 3L)")
=> java.util.HashSet.newHashSet($n) :: matchesWithBind($cap, "(int) ((4L * $n + 2L) / 3L)")
=> java.util.HashSet.newHashSet($cap) :: otherwise
;;

"convert to factory method for creating pre-sized Sets using initial number of entries instead of table capacity.":
new java.util.LinkedHashSet<$T$>($cap) :: $cap instanceof int && sourceVersionGE(19)
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(int) Math.ceil($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(int) ($n / $fac)") && matchesAny($fac, "0.75", "0.75f")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(int) ($n / $fac + $one)") && matchesAny($fac, "0.75", "0.75f") && matchesAny($one, "1", "1.0", "1.0f")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "($n * 4 + 2) / 3")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(4 * $n + 2) / 3")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "($n * 4) / 3 + 1")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "($n * 4) / 3")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(4 * $n) / 3 + 1")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(4 * $n) / 3")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "$n * 4 / 3 + 1")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "$n * 4 / 3")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "4 * $n / 3 + 1")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "4 * $n / 3")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(int) (($n * 4L + 2L) / 3L)")
=> java.util.LinkedHashSet.newLinkedHashSet($n) :: matchesWithBind($cap, "(int) ((4L * $n + 2L) / 3L)")
=> java.util.LinkedHashSet.newLinkedHashSet($cap) :: otherwise
;;


<?
    public boolean isEmpty(Variable var) throws Throwable {
        return !context.getIndexedVariables(var).iterator().hasNext();
    }

    public boolean isIntLiteral(Variable var) throws Throwable {
        TreePath tp = APIAccessor.IMPL.getSingleVariable(context, var);
        return tp != null && tp.getLeaf().getKind() == Kind.INT_LITERAL;
    }
?>