diff --git a/docs/codeql/codeql-language-guides/customizing-library-models-for-java.rst b/docs/codeql/codeql-language-guides/customizing-library-models-for-java.rst
index 950fdc7bf248..37e1fb35450e 100644
--- a/docs/codeql/codeql-language-guides/customizing-library-models-for-java.rst
+++ b/docs/codeql/codeql-language-guides/customizing-library-models-for-java.rst
@@ -397,6 +397,8 @@ The following components are supported:
 - **SyntheticGlobal[**\ `name`\ **]** selects the synthetic global with name `name`.
 - **ArrayElement** selects the elements of an array.
 - **Element** selects the elements of a collection-like container.
+- **WithoutElement** selects a collection-like container without its elements. This is for input only.
+- **WithElement** selects the elements of a collection-like container, but points to the container itself. This is for input only.
 - **MapKey** selects the element keys of a map.
 - **MapValue** selects the element values of a map.
 
diff --git a/java/ql/lib/change-notes/2023-08-04-mad-withoutelement.md b/java/ql/lib/change-notes/2023-08-04-mad-withoutelement.md
new file mode 100644
index 000000000000..f5e5cda8896f
--- /dev/null
+++ b/java/ql/lib/change-notes/2023-08-04-mad-withoutelement.md
@@ -0,0 +1,4 @@
+---
+category: minorAnalysis
+---
+* Add support for `WithElement` and `WithoutElement` for MaD access paths.
\ No newline at end of file
diff --git a/java/ql/lib/ext/java.util.model.yml b/java/ql/lib/ext/java.util.model.yml
index 15ab5e0c0bef..feb7ff473bd6 100644
--- a/java/ql/lib/ext/java.util.model.yml
+++ b/java/ql/lib/ext/java.util.model.yml
@@ -140,7 +140,8 @@ extensions:
       - ["java.util", "LinkedHashSet", False, "LinkedHashSet", "(Collection)", "", "Argument[0].Element", "Argument[this].Element", "value", "manual"]
       - ["java.util", "LinkedList", False, "LinkedList", "(Collection)", "", "Argument[0].Element", "Argument[this].Element", "value", "manual"]
       - ["java.util", "List", True, "add", "(int,Object)", "", "Argument[1]", "Argument[this].Element", "value", "manual"]
-      - ["java.util", "List", True, "addAll", "(int,Collection)", "", "Argument[1].Element", "Argument[this].Element", "value", "manual"]
+      - ["java.util", "List", True, "addAll", "(int,Collection)", "", "Argument[1].WithElement", "Argument[this]", "value", "manual"]
+      - ["java.util", "List", True, "clear", "()", "", "Argument[this].WithoutElement", "Argument[this]", "value", "manual"]
       - ["java.util", "List", False, "copyOf", "(Collection)", "", "Argument[0].Element", "ReturnValue.Element", "value", "manual"]
       - ["java.util", "List", True, "get", "(int)", "", "Argument[this].Element", "ReturnValue", "value", "manual"]
       - ["java.util", "List", True, "listIterator", "", "", "Argument[this].Element", "ReturnValue.Element", "value", "manual"]
@@ -313,6 +314,7 @@ extensions:
       - ["java.util", "Scanner", True, "useLocale", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
       - ["java.util", "Scanner", True, "useRadix", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
       - ["java.util", "Set", False, "copyOf", "(Collection)", "", "Argument[0].Element", "ReturnValue.Element", "value", "manual"]
+      - ["java.util", "Set", False, "clear", "()", "", "Argument[this].WithoutElement", "Argument[this]", "value", "manual"]
       - ["java.util", "Set", False, "of", "(Object)", "", "Argument[0]", "ReturnValue.Element", "value", "manual"]
       - ["java.util", "Set", False, "of", "(Object,Object)", "", "Argument[0..1]", "ReturnValue.Element", "value", "manual"]
       - ["java.util", "Set", False, "of", "(Object,Object,Object)", "", "Argument[0..2]", "ReturnValue.Element", "value", "manual"]
@@ -424,10 +426,8 @@ extensions:
       # When `WithoutElement` is implemented, these should be changed to summary models of the form `Argument[this].WithoutElement -> Argument[this]`.
       - ["java.util", "Collection", "removeIf", "(Predicate)", "summary", "manual"]
       - ["java.util", "Iterator", "remove", "()", "summary", "manual"]
-      - ["java.util", "List", "clear", "()", "summary", "manual"]
       - ["java.util", "List", "remove", "(Object)", "summary", "manual"]
       - ["java.util", "Map", "clear", "()", "summary", "manual"]
-      - ["java.util", "Set", "clear", "()", "summary", "manual"]
       - ["java.util", "Set", "remove", "(Object)", "summary", "manual"]
       - ["java.util", "Set", "removeAll", "(Collection)", "summary", "manual"]
 
diff --git a/java/ql/lib/semmle/code/java/dataflow/ExternalFlow.qll b/java/ql/lib/semmle/code/java/dataflow/ExternalFlow.qll
index c04126d5f7f6..b7ef1410bfa5 100644
--- a/java/ql/lib/semmle/code/java/dataflow/ExternalFlow.qll
+++ b/java/ql/lib/semmle/code/java/dataflow/ExternalFlow.qll
@@ -35,8 +35,9 @@
  *    or method, or a parameter.
  * 7. The `input` column specifies how data enters the element selected by the
  *    first 6 columns, and the `output` column specifies how data leaves the
- *    element selected by the first 6 columns. An `input` can be either "",
- *    "Argument[n]", "Argument[n1..n2]", "ReturnValue":
+ *    element selected by the first 6 columns. An `input` can be a dot separated
+ *    path consisting of either "", "Argument[n]", "Argument[n1..n2]",
+ *    "ReturnValue", "Element", "WithoutElement", or "WithElement":
  *    - "": Selects a write to the selected element in case this is a field.
  *    - "Argument[n]": Selects an argument in a call to the selected element.
  *      The arguments are zero-indexed, and `this` specifies the qualifier.
@@ -44,9 +45,15 @@
  *      the given range. The range is inclusive at both ends.
  *    - "ReturnValue": Selects a value being returned by the selected element.
  *      This requires that the selected element is a method with a body.
+ *    - "Element": Selects the collection elements of the selected element.
+ *    - "WithoutElement": Selects the selected element but without
+ *       its collection elements.
+ *    - "WithElement": Selects the collection elements of the selected element, but
+ *       points to the selected element.
  *
- *    An `output` can be either "", "Argument[n]", "Argument[n1..n2]", "Parameter",
- *    "Parameter[n]", "Parameter[n1..n2]", or "ReturnValue":
+ *    An `output` can be can be a dot separated path consisting of either "",
+ *    "Argument[n]", "Argument[n1..n2]", "Parameter", "Parameter[n]",
+ *    "Parameter[n1..n2]", "ReturnValue", or "Element":
  *    - "": Selects a read of a selected field, or a selected parameter.
  *    - "Argument[n]": Selects the post-update value of an argument in a call to the
  *      selected element. That is, the value of the argument after the call returns.
@@ -61,6 +68,7 @@
  *    - "Parameter[n1..n2]": Similar to "Parameter[n]" but selects any parameter
  *      in the given range. The range is inclusive at both ends.
  *    - "ReturnValue": Selects the return value of a call to the selected element.
+ *    - "Element": Selects the collection elements of the selected element.
  * 8. The `kind` column is a tag that can be referenced from QL to determine to
  *    which classes the interpreted elements should be added. For example, for
  *    sources "remote" indicates a default remote flow source, and for summaries
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/FlowSummaryImplSpecific.qll b/java/ql/lib/semmle/code/java/dataflow/internal/FlowSummaryImplSpecific.qll
index d9782c2eecf1..b99c96c80855 100644
--- a/java/ql/lib/semmle/code/java/dataflow/internal/FlowSummaryImplSpecific.qll
+++ b/java/ql/lib/semmle/code/java/dataflow/internal/FlowSummaryImplSpecific.qll
@@ -170,6 +170,10 @@ predicate neutralSummaryElement(SummarizedCallableBase c, string provenance) {
 bindingset[c]
 SummaryComponent interpretComponentSpecific(AccessPathToken c) {
   exists(Content content | parseContent(c, content) and result = SummaryComponent::content(content))
+  or
+  c = "WithoutElement" and result = SummaryComponent::withoutContent(any(CollectionContent cc))
+  or
+  c = "WithElement" and result = SummaryComponent::withContent(any(CollectionContent cc))
 }
 
 /** Gets the summary component for specification component `c`, if any. */
@@ -196,6 +200,10 @@ private string getContentSpecific(Content c) {
 /** Gets the textual representation of the content in the format used for MaD models. */
 string getMadRepresentationSpecific(SummaryComponent sc) {
   exists(Content c | sc = TContentSummaryComponent(c) and result = getContentSpecific(c))
+  or
+  sc = TWithoutContentSummaryComponent(_) and result = "WithoutElement"
+  or
+  sc = TWithContentSummaryComponent(_) and result = "WithElement"
 }
 
 bindingset[pos]
diff --git a/java/ql/test/library-tests/dataflow/collections/B.java b/java/ql/test/library-tests/dataflow/collections/B.java
index 0bb2b74d7496..7d9c418c162b 100644
--- a/java/ql/test/library-tests/dataflow/collections/B.java
+++ b/java/ql/test/library-tests/dataflow/collections/B.java
@@ -9,6 +9,7 @@ public class B {
   static void sink(Object obj) { }
 
   static Object[] storeArrayElement(Object obj) { return new Object[] {obj}; }
+  static Set storeSetElement(Object obj) { return Set.of(obj); }
 
   static Object readArrayElement(Object[] obj) { return obj[0]; }
   static boolean readArrayElement(boolean[] obj) { return obj[0]; }
@@ -49,96 +50,96 @@ static void sink(Object obj) { }
 
   void foo() throws InterruptedException {
     {
-      // "java.util;Map$Entry;true;getKey;;;MapKey of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map$Entry;true;getKey;;;Argument[this].MapKey;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapKeyEntry(source()); out = ((Map.Entry)in).getKey(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map$Entry;true;getValue;;;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map$Entry;true;getValue;;;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValueEntry(source()); out = ((Map.Entry)in).getValue(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map$Entry;true;setValue;;;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map$Entry;true;setValue;;;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValueEntry(source()); out = ((Map.Entry)in).setValue(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map$Entry;true;setValue;;;Argument[0];MapValue of Argument[this];value;manual",
+      // "java.util;Map$Entry;true;setValue;;;Argument[0];Argument[this].MapValue;value;manual",
       Map.Entry out = null;
       Object in = source(); out.setValue(in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.lang;Iterable;true;iterator;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.lang;Iterable;true;iterator;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Iterator out = null;
       Iterable in = storeElementList(source()); out = in.iterator(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.lang;Iterable;true;spliterator;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.lang;Iterable;true;spliterator;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Spliterator out = null;
       Iterable in = storeElementList(source()); out = in.spliterator(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Iterator;true;next;;;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Iterator;true;next;;;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Iterator in = storeElementListIterator(source()); out = in.next(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;ListIterator;true;previous;;;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;ListIterator;true;previous;;;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       ListIterator in = storeElementListIterator(source()); out = in.previous(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;ListIterator;true;add;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;ListIterator;true;add;(Object);;Argument[0];Argument[this].Element;value;manual",
       ListIterator out = null;
       Object in = source(); out.add(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;ListIterator;true;set;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;ListIterator;true;set;(Object);;Argument[0];Argument[this].Element;value;manual",
       ListIterator out = null;
       Object in = source(); out.set(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Enumeration;true;asIterator;;;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Enumeration;true;asIterator;;;Argument[this].Element;ReturnValue.Element;value;manual",
       Iterator out = null;
       Enumeration in = storeElementEnumeration(source()); out = in.asIterator(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Enumeration;true;nextElement;;;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Enumeration;true;nextElement;;;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Enumeration in = storeElementEnumeration(source()); out = in.nextElement(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;computeIfAbsent;;;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map;true;computeIfAbsent;;;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Map)in).computeIfAbsent(null,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;computeIfAbsent;;;ReturnValue of Argument[1];ReturnValue;value;manual",
+      // "java.util;Map;true;computeIfAbsent;;;Argument[1].ReturnValue;ReturnValue;value;manual",
       Object out = ((Map)null).computeIfAbsent(null,k -> source()); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;computeIfAbsent;;;ReturnValue of Argument[1];MapValue of Argument[this];value;manual",
+      // "java.util;Map;true;computeIfAbsent;;;Argument[1].ReturnValue;Argument[this].MapValue;value;manual",
       Map out = null;
       out.computeIfAbsent(null,k -> source()); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;entrySet;;;MapValue of Argument[this];MapValue of Element of ReturnValue;value;manual",
+      // "java.util;Map;true;entrySet;;;Argument[this].MapValue;ReturnValue.Element.MapValue;value;manual",
       Set<Map.Entry> out = null;
       Object in = storeMapValue(source()); out = ((Map)in).entrySet(); sink(readMapValue(readElement(out))); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;entrySet;;;MapKey of Argument[this];MapKey of Element of ReturnValue;value;manual",
+      // "java.util;Map;true;entrySet;;;Argument[this].MapKey;ReturnValue.Element.MapKey;value;manual",
       Set<Map.Entry> out = null;
       Object in = storeMapKey(source()); out = ((Map)in).entrySet(); sink(readMapKey(readElement(out))); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;get;;;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map;true;get;;;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Map)in).get(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;getOrDefault;;;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map;true;getOrDefault;;;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Map)in).getOrDefault(null,null); sink(out); // $ hasValueFlow
     }
@@ -148,1707 +149,1727 @@ void foo() throws InterruptedException {
       Object in = source(); out = ((Map)null).getOrDefault(null,in); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;put;;;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map;true;put;;;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Map)in).put(null,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;put;;;Argument[0];MapKey of Argument[this];value;manual",
+      // "java.util;Map;true;put;;;Argument[0];Argument[this].MapKey;value;manual",
       Map out = null;
       Object in = source(); out.put(in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;put;;;Argument[1];MapValue of Argument[this];value;manual",
+      // "java.util;Map;true;put;;;Argument[1];Argument[this].MapValue;value;manual",
       Map out = null;
       Object in = source(); out.put(null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;putIfAbsent;;;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map;true;putIfAbsent;;;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Map)in).putIfAbsent(null,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;putIfAbsent;;;Argument[0];MapKey of Argument[this];value;manual",
+      // "java.util;Map;true;putIfAbsent;;;Argument[0];Argument[this].MapKey;value;manual",
       Map out = null;
       Object in = source(); out.putIfAbsent(in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;putIfAbsent;;;Argument[1];MapValue of Argument[this];value;manual",
+      // "java.util;Map;true;putIfAbsent;;;Argument[1];Argument[this].MapValue;value;manual",
       Map out = null;
       Object in = source(); out.putIfAbsent(null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;remove;(Object);;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map;true;remove;(Object);;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Map)in).remove(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;replace;(Object,Object);;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Map;true;replace;(Object,Object);;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Map)in).replace(null,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;replace;(Object,Object);;Argument[0];MapKey of Argument[this];value;manual",
+      // "java.util;Map;true;replace;(Object,Object);;Argument[0];Argument[this].MapKey;value;manual",
       Map out = null;
       Object in = source(); out.replace(in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;replace;(Object,Object);;Argument[1];MapValue of Argument[this];value;manual",
+      // "java.util;Map;true;replace;(Object,Object);;Argument[1];Argument[this].MapValue;value;manual",
       Map out = null;
       Object in = source(); out.replace(null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;replace;(Object,Object,Object);;Argument[0];MapKey of Argument[this];value;manual",
+      // "java.util;Map;true;replace;(Object,Object,Object);;Argument[0];Argument[this].MapKey;value;manual",
       Map out = null;
       Object in = source(); out.replace(in,null,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;replace;(Object,Object,Object);;Argument[2];MapValue of Argument[this];value;manual",
+      // "java.util;Map;true;replace;(Object,Object,Object);;Argument[2];Argument[this].MapValue;value;manual",
       Map out = null;
       Object in = source(); out.replace(null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;keySet;();;MapKey of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Map;true;keySet;();;Argument[this].MapKey;ReturnValue.Element;value;manual",
       Set out = null;
       Object in = storeMapKey(source()); out = ((Map)in).keySet(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;values;();;MapValue of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Map;true;values;();;Argument[this].MapValue;ReturnValue.Element;value;manual",
       Iterable out = null;
       Object in = storeMapValue(source()); out = ((Map)in).values(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;merge;(Object,Object,BiFunction);;Argument[1];MapValue of Argument[this];value;manual",
+      // "java.util;Map;true;merge;(Object,Object,BiFunction);;Argument[1];Argument[this].MapValue;value;manual",
       Map out = null;
       Object in = source(); out.merge(null,in,null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;putAll;(Map);;MapKey of Argument[0];MapKey of Argument[this];value;manual",
+      // "java.util;Map;true;putAll;(Map);;Argument[0].MapKey;Argument[this].MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out.putAll((Map)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;true;putAll;(Map);;MapValue of Argument[0];MapValue of Argument[this];value;manual",
+      // "java.util;Map;true;putAll;(Map);;Argument[0].MapValue;Argument[this].MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out.putAll((Map)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collection;true;parallelStream;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Collection;true;parallelStream;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Stream out = null;
       Collection in = storeElementList(source()); out = in.parallelStream(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collection;true;stream;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Collection;true;stream;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Stream out = null;
       Collection in = storeElementList(source()); out = in.stream(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collection;true;toArray;;;Element of Argument[this];ArrayElement of ReturnValue;value;manual",
+      // "java.util;Collection;true;toArray;;;Argument[this].Element;ReturnValue.ArrayElement;value;manual",
       Object[] out = null;
       Collection in = storeElementList(source()); out = in.toArray(); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collection;true;toArray;;;Element of Argument[this];ArrayElement of Argument[0];value;manual",
+      // "java.util;Collection;true;toArray;;;Argument[this].Element;Argument[0].ArrayElement;value;manual",
       Object[] out = null;
       Collection in = storeElementList(source()); in.toArray(out); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collection;true;add;;;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Collection;true;add;;;Argument[0];Argument[this].Element;value;manual",
       Collection out = null;
       Object in = source(); out.add(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collection;true;addAll;;;Element of Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Collection;true;addAll;;;Argument[0].Element;Argument[this].Element;value;manual",
       Collection out = null;
       Collection in = storeElementList(source()); out.addAll(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;get;(int);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;List;true;get;(int);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       List in = storeElementList(source()); out = in.get(0); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;listIterator;;;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;List;true;listIterator;;;Argument[this].Element;ReturnValue.Element;value;manual",
       ListIterator out = null;
       List in = storeElementList(source()); out = in.listIterator(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;remove;(int);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;List;true;remove;(int);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       List in = storeElementList(source()); out = in.remove(0); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;set;(int,Object);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;List;true;set;(int,Object);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       List in = storeElementList(source()); out = in.set(0,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;set;(int,Object);;Argument[1];Element of Argument[this];value;manual",
+      // "java.util;List;true;set;(int,Object);;Argument[1];Argument[this].Element;value;manual",
       List out = null;
       Object in = source(); out.set(0,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;subList;;;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;List;true;subList;;;Argument[this].Element;ReturnValue.Element;value;manual",
       List out = null;
       List in = storeElementList(source()); out = in.subList(0,0); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;add;(int,Object);;Argument[1];Element of Argument[this];value;manual",
+      // "java.util;List;true;add;(int,Object);;Argument[1];Argument[this].Element;value;manual",
       List out = null;
       Object in = source(); out.add(0,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;true;addAll;(int,Collection);;Element of Argument[1];Element of Argument[this];value;manual",
+      // "java.util;List;true;addAll;(int,Collection);;Argument[1].Element;Argument[this].Element;value;manual",
       List out = null;
       Collection in = storeElementList(source()); out.addAll(0,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;elementAt;(int);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;List;true;clear;;;Argument[this].WithoutElement;Argument[this];value;manual"
+      List out = null;
+      List in = storeElementList(source()); out = in; out.clear(); sink(readElement(out)); // No flow
+    }
+    {
+      // "java.util;List;true;clear;;;Argument[this].WithoutElement;Argument[this];value;manual"
+      List out = null;
+      List in = (List)source(); out = in; out.clear(); sink(out); // $ hasValueFlow
+    }
+    {
+      // "java.util;Vector;true;elementAt;(int);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Vector in = storeElementStack(source()); out = in.elementAt(0); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;elements;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Vector;true;elements;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Enumeration out = null;
       Vector in = storeElementStack(source()); out = in.elements(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;firstElement;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Vector;true;firstElement;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Vector in = storeElementStack(source()); out = in.firstElement(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;lastElement;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Vector;true;lastElement;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Vector in = storeElementStack(source()); out = in.lastElement(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;addElement;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Vector;true;addElement;(Object);;Argument[0];Argument[this].Element;value;manual",
       Vector out = null;
       Object in = source(); out.addElement(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;insertElementAt;(Object,int);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Vector;true;insertElementAt;(Object,int);;Argument[0];Argument[this].Element;value;manual",
       Vector out = null;
       Object in = source(); out.insertElementAt(in,0); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;setElementAt;(Object,int);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Vector;true;setElementAt;(Object,int);;Argument[0];Argument[this].Element;value;manual",
       Vector out = null;
       Object in = source(); out.setElementAt(in,0); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Vector;true;copyInto;(Object[]);;Element of Argument[this];ArrayElement of Argument[0];value;manual",
+      // "java.util;Vector;true;copyInto;(Object[]);;Argument[this].Element;Argument[0].ArrayElement;value;manual",
       Object[] out = null;
       Vector in = storeElementStack(source()); in.copyInto(out); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Stack;true;peek;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Stack;true;peek;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Stack in = storeElementStack(source()); out = in.peek(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Stack;true;pop;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Stack;true;pop;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Stack in = storeElementStack(source()); out = in.pop(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Stack;true;push;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Stack;true;push;(Object);;Argument[0];Argument[this].Element;value;manual",
       Stack out = null;
       Object in = source(); out.push(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Queue;true;element;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Queue;true;element;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Queue in = storeElementBlockingDeque(source()); out = in.element(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Queue;true;peek;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Queue;true;peek;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Queue in = storeElementBlockingDeque(source()); out = in.peek(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Queue;true;poll;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Queue;true;poll;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Queue in = storeElementBlockingDeque(source()); out = in.poll(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Queue;true;remove;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Queue;true;remove;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Queue in = storeElementBlockingDeque(source()); out = in.remove(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Queue;true;offer;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Queue;true;offer;(Object);;Argument[0];Argument[this].Element;value;manual",
       Queue out = null;
       Object in = source(); out.offer(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;descendingIterator;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Deque;true;descendingIterator;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Iterator out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.descendingIterator(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;getFirst;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;getFirst;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.getFirst(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;getLast;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;getLast;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.getLast(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;peekFirst;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;peekFirst;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.peekFirst(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;peekLast;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;peekLast;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.peekLast(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;pollFirst;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;pollFirst;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.pollFirst(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;pollLast;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;pollLast;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.pollLast(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;pop;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;pop;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.pop(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;removeFirst;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;removeFirst;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.removeFirst(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;removeLast;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;Deque;true;removeLast;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       Deque in = storeElementBlockingDeque(source()); out = in.removeLast(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;push;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Deque;true;push;(Object);;Argument[0];Argument[this].Element;value;manual",
       Deque out = null;
       Object in = source(); out.push(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;offerLast;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Deque;true;offerLast;(Object);;Argument[0];Argument[this].Element;value;manual",
       Deque out = null;
       Object in = source(); out.offerLast(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;offerFirst;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Deque;true;offerFirst;(Object);;Argument[0];Argument[this].Element;value;manual",
       Deque out = null;
       Object in = source(); out.offerFirst(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;addLast;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Deque;true;addLast;(Object);;Argument[0];Argument[this].Element;value;manual",
       Deque out = null;
       Object in = source(); out.addLast(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Deque;true;addFirst;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util;Deque;true;addFirst;(Object);;Argument[0];Argument[this].Element;value;manual",
       Deque out = null;
       Object in = source(); out.addFirst(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;pollFirst;(long,TimeUnit);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util.concurrent;BlockingDeque;true;pollFirst;(long,TimeUnit);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       BlockingDeque in = storeElementBlockingDeque(source()); out = in.pollFirst(0,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;pollLast;(long,TimeUnit);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util.concurrent;BlockingDeque;true;pollLast;(long,TimeUnit);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       BlockingDeque in = storeElementBlockingDeque(source()); out = in.pollLast(0,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;takeFirst;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util.concurrent;BlockingDeque;true;takeFirst;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       BlockingDeque in = storeElementBlockingDeque(source()); out = in.takeFirst(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;takeLast;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util.concurrent;BlockingDeque;true;takeLast;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       BlockingDeque in = storeElementBlockingDeque(source()); out = in.takeLast(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingQueue;true;poll;(long,TimeUnit);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util.concurrent;BlockingQueue;true;poll;(long,TimeUnit);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       BlockingQueue in = storeElementBlockingDeque(source()); out = in.poll(0,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingQueue;true;take;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util.concurrent;BlockingQueue;true;take;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       BlockingQueue in = storeElementBlockingDeque(source()); out = in.take(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingQueue;true;offer;(Object,long,TimeUnit);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;BlockingQueue;true;offer;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",
       BlockingQueue out = null;
       Object in = source(); out.offer(in,0,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingQueue;true;put;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;BlockingQueue;true;put;(Object);;Argument[0];Argument[this].Element;value;manual",
       BlockingQueue out = null;
       Object in = source(); out.put(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;offerLast;(Object,long,TimeUnit);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;BlockingDeque;true;offerLast;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",
       BlockingDeque out = null;
       Object in = source(); out.offerLast(in,0,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;offerFirst;(Object,long,TimeUnit);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;BlockingDeque;true;offerFirst;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",
       BlockingDeque out = null;
       Object in = source(); out.offerFirst(in,0,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;putLast;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;BlockingDeque;true;putLast;(Object);;Argument[0];Argument[this].Element;value;manual",
       BlockingDeque out = null;
       Object in = source(); out.putLast(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingDeque;true;putFirst;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;BlockingDeque;true;putFirst;(Object);;Argument[0];Argument[this].Element;value;manual",
       BlockingDeque out = null;
       Object in = source(); out.putFirst(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingQueue;true;drainTo;(Collection,int);;Element of Argument[this];Element of Argument[0];value;manual",
+      // "java.util.concurrent;BlockingQueue;true;drainTo;(Collection,int);;Argument[this].Element;Argument[0].Element;value;manual",
       Collection out = null;
       BlockingQueue in = storeElementBlockingDeque(source()); in.drainTo(out,0); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;BlockingQueue;true;drainTo;(Collection);;Element of Argument[this];Element of Argument[0];value;manual",
+      // "java.util.concurrent;BlockingQueue;true;drainTo;(Collection);;Argument[this].Element;Argument[0].Element;value;manual",
       Collection out = null;
       BlockingQueue in = storeElementBlockingDeque(source()); in.drainTo(out); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;ConcurrentHashMap;true;elements;();;MapValue of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util.concurrent;ConcurrentHashMap;true;elements;();;Argument[this].MapValue;ReturnValue.Element;value;manual",
       Enumeration out = null;
       Object in = storeMapValue(source()); out = ((ConcurrentHashMap)in).elements(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Dictionary;true;elements;();;MapValue of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;Dictionary;true;elements;();;Argument[this].MapValue;ReturnValue.Element;value;manual",
       Enumeration out = null;
       Object in = storeMapValue(source()); out = ((Dictionary)in).elements(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Dictionary;true;get;(Object);;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Dictionary;true;get;(Object);;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Dictionary)in).get(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Dictionary;true;put;(Object,Object);;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Dictionary;true;put;(Object,Object);;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Dictionary)in).put(null,null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Dictionary;true;put;(Object,Object);;Argument[0];MapKey of Argument[this];value;manual",
+      // "java.util;Dictionary;true;put;(Object,Object);;Argument[0];Argument[this].MapKey;value;manual",
       Dictionary out = null;
       Object in = source(); out.put(in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Dictionary;true;put;(Object,Object);;Argument[1];MapValue of Argument[this];value;manual",
+      // "java.util;Dictionary;true;put;(Object,Object);;Argument[1];Argument[this].MapValue;value;manual",
       Dictionary out = null;
       Object in = source(); out.put(null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Dictionary;true;remove;(Object);;MapValue of Argument[this];ReturnValue;value;manual",
+      // "java.util;Dictionary;true;remove;(Object);;Argument[this].MapValue;ReturnValue;value;manual",
       Object out = null;
       Object in = storeMapValue(source()); out = ((Dictionary)in).remove(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;ceilingEntry;(Object);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;ceilingEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).ceilingEntry(null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;ceilingEntry;(Object);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;ceilingEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).ceilingEntry(null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;descendingMap;();;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;descendingMap;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).descendingMap(); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;descendingMap;();;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;descendingMap;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).descendingMap(); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;firstEntry;();;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;firstEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).firstEntry(); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;firstEntry;();;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;firstEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).firstEntry(); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;floorEntry;(Object);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;floorEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).floorEntry(null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;floorEntry;(Object);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;floorEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).floorEntry(null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;headMap;(Object,boolean);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;headMap;(Object,boolean);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).headMap(null,true); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;headMap;(Object,boolean);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;headMap;(Object,boolean);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).headMap(null,true); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;higherEntry;(Object);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;higherEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).higherEntry(null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;higherEntry;(Object);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;higherEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).higherEntry(null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;lastEntry;();;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;lastEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).lastEntry(); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;lastEntry;();;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;lastEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).lastEntry(); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;lowerEntry;(Object);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;lowerEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).lowerEntry(null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;lowerEntry;(Object);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;lowerEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).lowerEntry(null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;pollFirstEntry;();;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;pollFirstEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).pollFirstEntry(); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;pollFirstEntry;();;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;pollFirstEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).pollFirstEntry(); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;pollLastEntry;();;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;pollLastEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).pollLastEntry(); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;pollLastEntry;();;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;pollLastEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).pollLastEntry(); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;subMap;(Object,boolean,Object,boolean);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;subMap;(Object,boolean,Object,boolean);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).subMap(null,true,null,true); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;subMap;(Object,boolean,Object,boolean);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;subMap;(Object,boolean,Object,boolean);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).subMap(null,true,null,true); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;tailMap;(Object,boolean);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;tailMap;(Object,boolean);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((NavigableMap)in).tailMap(null,true); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableMap;true;tailMap;(Object,boolean);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;NavigableMap;true;tailMap;(Object,boolean);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((NavigableMap)in).tailMap(null,true); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;ceiling;(Object);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;ceiling;(Object);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.ceiling(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;descendingIterator;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;descendingIterator;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Iterator out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.descendingIterator(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;descendingSet;();;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;descendingSet;();;Argument[this].Element;ReturnValue.Element;value;manual",
       Set out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.descendingSet(); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;floor;(Object);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;floor;(Object);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.floor(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;headSet;(Object,boolean);;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;headSet;(Object,boolean);;Argument[this].Element;ReturnValue.Element;value;manual",
       Set out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.headSet(null,true); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;higher;(Object);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;higher;(Object);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.higher(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;lower;(Object);;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;lower;(Object);;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.lower(null); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;pollFirst;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;pollFirst;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.pollFirst(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;pollLast;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;pollLast;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.pollLast(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;subSet;(Object,boolean,Object,boolean);;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;subSet;(Object,boolean,Object,boolean);;Argument[this].Element;ReturnValue.Element;value;manual",
       Set out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.subSet(null,true,null,true); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;NavigableSet;true;tailSet;(Object,boolean);;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;NavigableSet;true;tailSet;(Object,boolean);;Argument[this].Element;ReturnValue.Element;value;manual",
       Set out = null;
       NavigableSet in = storeElementNavSet(source()); out = in.tailSet(null,true); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedMap;true;headMap;(Object);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;SortedMap;true;headMap;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((SortedMap)in).headMap(null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedMap;true;headMap;(Object);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;SortedMap;true;headMap;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((SortedMap)in).headMap(null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedMap;true;subMap;(Object,Object);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;SortedMap;true;subMap;(Object,Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((SortedMap)in).subMap(null,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedMap;true;subMap;(Object,Object);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;SortedMap;true;subMap;(Object,Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((SortedMap)in).subMap(null,null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedMap;true;tailMap;(Object);;MapKey of Argument[this];MapKey of ReturnValue;value;manual",
+      // "java.util;SortedMap;true;tailMap;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((SortedMap)in).tailMap(null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedMap;true;tailMap;(Object);;MapValue of Argument[this];MapValue of ReturnValue;value;manual",
+      // "java.util;SortedMap;true;tailMap;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((SortedMap)in).tailMap(null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedSet;true;first;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;SortedSet;true;first;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       SortedSet in = storeElementNavSet(source()); out = in.first(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;SortedSet;true;headSet;(Object);;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;SortedSet;true;headSet;(Object);;Argument[this].Element;ReturnValue.Element;value;manual",
       Set out = null;
       SortedSet in = storeElementNavSet(source()); out = in.headSet(null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedSet;true;last;();;Element of Argument[this];ReturnValue;value;manual",
+      // "java.util;SortedSet;true;last;();;Argument[this].Element;ReturnValue;value;manual",
       Object out = null;
       SortedSet in = storeElementNavSet(source()); out = in.last(); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;SortedSet;true;subSet;(Object,Object);;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;SortedSet;true;subSet;(Object,Object);;Argument[this].Element;ReturnValue.Element;value;manual",
       Set out = null;
       SortedSet in = storeElementNavSet(source()); out = in.subSet(null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;SortedSet;true;tailSet;(Object);;Element of Argument[this];Element of ReturnValue;value;manual",
+      // "java.util;SortedSet;true;tailSet;(Object);;Argument[this].Element;ReturnValue.Element;value;manual",
       Set out = null;
       SortedSet in = storeElementNavSet(source()); out = in.tailSet(null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;TransferQueue;true;tryTransfer;(Object,long,TimeUnit);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;TransferQueue;true;tryTransfer;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",
       TransferQueue out = null;
       Object in = source(); out.tryTransfer(in,0,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;TransferQueue;true;transfer;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;TransferQueue;true;transfer;(Object);;Argument[0];Argument[this].Element;value;manual",
       TransferQueue out = null;
       Object in = source(); out.transfer(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util.concurrent;TransferQueue;true;tryTransfer;(Object);;Argument[0];Element of Argument[this];value;manual",
+      // "java.util.concurrent;TransferQueue;true;tryTransfer;(Object);;Argument[0];Argument[this].Element;value;manual",
       TransferQueue out = null;
       Object in = source(); out.tryTransfer(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;copyOf;(Collection);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;copyOf;(Collection);;Argument[0].Element;ReturnValue.Element;value;manual",
       List out = null;
       Collection in = storeElementList(source()); out = List.copyOf(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object[]);;ArrayElement of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object[]);;Argument[0].ArrayElement;ReturnValue.Element;value;manual",
       List out = null;
       Object[] in = storeArrayElement(source()); out = List.of(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(in,null,null,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,in,null,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,in,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[9];Element of ReturnValue;value;manual",
+      // "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[9];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = List.of(null,null,null,null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;copyOf;(Map);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;copyOf;(Map);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = Map.copyOf((Map)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;copyOf;(Map);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;copyOf;(Map);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = Map.copyOf((Map)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;entry;(Object,Object);;Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;entry;(Object,Object);;Argument[0];ReturnValue.MapKey;value;manual",
       Map.Entry out = null;
       Object in = source(); out = Map.entry(in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;entry;(Object,Object);;Argument[1];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;entry;(Object,Object);;Argument[1];ReturnValue.MapValue;value;manual",
       Map.Entry out = null;
       Object in = source(); out = Map.entry(null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[0];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[1];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[1];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[2];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[2];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[3];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[3];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[4];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[4];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[5];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[5];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[6];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[6];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[7];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[7];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[8];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[8];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[9];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[9];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[10];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[10];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[11];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[11];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[12];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[12];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[13];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[13];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[14];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[14];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[15];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[15];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[16];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[16];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[17];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[17];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[18];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[18];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;of;;;Argument[19];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;of;;;Argument[19];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = Map.of(null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;ofEntries;;;MapKey of ArrayElement of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Map;false;ofEntries;;;Argument[0].MapKey.ArrayElement;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object[] in = storeArrayElement(storeMapKey(source())); out = Map.ofEntries((Map.Entry[])in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Map;false;ofEntries;;;MapValue of ArrayElement of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Map;false;ofEntries;;;Argument[0].MapValue.ArrayElement;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object[] in = storeArrayElement(storeMapValue(source())); out = Map.ofEntries((Map.Entry[])in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;copyOf;(Collection);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;true;clear;;;Argument[this].WithoutElement;Argument[this];value;manual"
+      Set out = null;
+      Set in = storeSetElement(source()); out = in; out.clear(); sink(readElement(out)); // No flow
+    }
+    {
+      // "java.util;Set;true;clear;;;Argument[this].WithoutElement;Argument[this];value;manual"
+      Set out = null;
+      Set in = (Set)source(); out = in; out.clear(); sink(out); // $ hasValueFlow
+    }
+    {
+      // "java.util;Set;false;copyOf;(Collection);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       Collection in = storeElementList(source()); out = Set.copyOf(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object[]);;ArrayElement of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object[]);;Argument[0].ArrayElement;ReturnValue.Element;value;manual",
       Set out = null;
       Object[] in = storeArrayElement(source()); out = Set.of(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(in,null,null,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,in,null,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,in,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[7];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[8];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[9];Element of ReturnValue;value;manual",
+      // "java.util;Set;false;of;(Object,Object,Object,Object,Object,Object,Object,Object,Object,Object);;Argument[9];ReturnValue.Element;value;manual",
       Set out = null;
       Object in = source(); out = Set.of(null,null,null,null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;stream;;;ArrayElement of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Arrays;false;stream;;;Argument[0].ArrayElement;ReturnValue.Element;value;manual",
       Stream out = null;
       Object[] in = storeArrayElement(source()); out = ((Arrays)null).stream(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;spliterator;;;ArrayElement of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Arrays;false;spliterator;;;Argument[0].ArrayElement;ReturnValue.Element;value;manual",
       Spliterator out = null;
       Object[] in = storeArrayElement(source()); out = ((Arrays)null).spliterator(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;copyOfRange;;;ArrayElement of Argument[0];ArrayElement of ReturnValue;value;manual",
+      // "java.util;Arrays;false;copyOfRange;;;Argument[0].ArrayElement;ReturnValue.ArrayElement;value;manual",
       Object[] out = null;
       Object[] in = storeArrayElement(source()); out = ((Arrays)null).copyOfRange(in,0,0); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;copyOf;;;ArrayElement of Argument[0];ArrayElement of ReturnValue;value;manual",
+      // "java.util;Arrays;false;copyOf;;;Argument[0].ArrayElement;ReturnValue.ArrayElement;value;manual",
       Object[] out = null;
       Object[] in = storeArrayElement(source()); out = ((Arrays)null).copyOf(in,0); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;list;(Enumeration);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;list;(Enumeration);;Argument[0].Element;ReturnValue.Element;value;manual",
       List out = null;
       Enumeration in = storeElementEnumeration(source()); out = ((Collections)null).list(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;enumeration;(Collection);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;enumeration;(Collection);;Argument[0].Element;ReturnValue.Element;value;manual",
       Enumeration out = null;
       Collection in = storeElementList(source()); out = ((Collections)null).enumeration(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;nCopies;(int,Object);;Argument[1];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;nCopies;(int,Object);;Argument[1];ReturnValue.Element;value;manual",
       Collection out = null;
       Object in = source(); out = ((Collections)null).nCopies(0,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;singletonMap;(Object,Object);;Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;singletonMap;(Object,Object);;Argument[0];ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = source(); out = ((Collections)null).singletonMap(in,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;singletonMap;(Object,Object);;Argument[1];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;singletonMap;(Object,Object);;Argument[1];ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = source(); out = ((Collections)null).singletonMap(null,in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;singletonList;(Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;singletonList;(Object);;Argument[0];ReturnValue.Element;value;manual",
       List out = null;
       Object in = source(); out = ((Collections)null).singletonList(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;singleton;(Object);;Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;singleton;(Object);;Argument[0];ReturnValue.Element;value;manual",
       Collection out = null;
       Object in = source(); out = ((Collections)null).singleton(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedNavigableMap;(NavigableMap,Class,Class);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedNavigableMap;(NavigableMap,Class,Class);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).checkedNavigableMap((NavigableMap)in,null,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedNavigableMap;(NavigableMap,Class,Class);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedNavigableMap;(NavigableMap,Class,Class);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).checkedNavigableMap((NavigableMap)in,null,null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedSortedMap;(SortedMap,Class,Class);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedSortedMap;(SortedMap,Class,Class);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).checkedSortedMap((SortedMap)in,null,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedSortedMap;(SortedMap,Class,Class);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedSortedMap;(SortedMap,Class,Class);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).checkedSortedMap((SortedMap)in,null,null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedMap;(Map,Class,Class);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedMap;(Map,Class,Class);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).checkedMap((Map)in,null,null); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedMap;(Map,Class,Class);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedMap;(Map,Class,Class);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).checkedMap((Map)in,null,null); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedList;(List,Class);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedList;(List,Class);;Argument[0].Element;ReturnValue.Element;value;manual",
       List out = null;
       List in = storeElementList(source()); out = ((Collections)null).checkedList(in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedNavigableSet;(NavigableSet,Class);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedNavigableSet;(NavigableSet,Class);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       NavigableSet in = storeElementNavSet(source()); out = ((Collections)null).checkedNavigableSet(in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedSortedSet;(SortedSet,Class);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedSortedSet;(SortedSet,Class);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       SortedSet in = storeElementNavSet(source()); out = ((Collections)null).checkedSortedSet(in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedSet;(Set,Class);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedSet;(Set,Class);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       Set in = storeElementNavSet(source()); out = ((Collections)null).checkedSet(in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;checkedCollection;(Collection,Class);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;checkedCollection;(Collection,Class);;Argument[0].Element;ReturnValue.Element;value;manual",
       Collection out = null;
       Collection in = storeElementList(source()); out = ((Collections)null).checkedCollection(in,null); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedNavigableMap;(NavigableMap);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedNavigableMap;(NavigableMap);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).synchronizedNavigableMap((NavigableMap)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedNavigableMap;(NavigableMap);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedNavigableMap;(NavigableMap);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).synchronizedNavigableMap((NavigableMap)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedSortedMap;(SortedMap);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedSortedMap;(SortedMap);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).synchronizedSortedMap((SortedMap)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedSortedMap;(SortedMap);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedSortedMap;(SortedMap);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).synchronizedSortedMap((SortedMap)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedMap;(Map);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedMap;(Map);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).synchronizedMap((Map)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedMap;(Map);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedMap;(Map);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).synchronizedMap((Map)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedList;(List);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedList;(List);;Argument[0].Element;ReturnValue.Element;value;manual",
       List out = null;
       List in = storeElementList(source()); out = ((Collections)null).synchronizedList(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedNavigableSet;(NavigableSet);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedNavigableSet;(NavigableSet);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       NavigableSet in = storeElementNavSet(source()); out = ((Collections)null).synchronizedNavigableSet(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedSortedSet;(SortedSet);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedSortedSet;(SortedSet);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       SortedSet in = storeElementNavSet(source()); out = ((Collections)null).synchronizedSortedSet(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedSet;(Set);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedSet;(Set);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       Set in = storeElementNavSet(source()); out = ((Collections)null).synchronizedSet(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;synchronizedCollection;(Collection);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;synchronizedCollection;(Collection);;Argument[0].Element;ReturnValue.Element;value;manual",
       Collection out = null;
       Collection in = storeElementList(source()); out = ((Collections)null).synchronizedCollection(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableNavigableMap;(NavigableMap);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableNavigableMap;(NavigableMap);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).unmodifiableNavigableMap((NavigableMap)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableNavigableMap;(NavigableMap);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableNavigableMap;(NavigableMap);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).unmodifiableNavigableMap((NavigableMap)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableSortedMap;(SortedMap);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableSortedMap;(SortedMap);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).unmodifiableSortedMap((SortedMap)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableSortedMap;(SortedMap);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableSortedMap;(SortedMap);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).unmodifiableSortedMap((SortedMap)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableMap;(Map);;MapKey of Argument[0];MapKey of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableMap;(Map);;Argument[0].MapKey;ReturnValue.MapKey;value;manual",
       Map out = null;
       Object in = storeMapKey(source()); out = ((Collections)null).unmodifiableMap((Map)in); sink(readMapKey(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableMap;(Map);;MapValue of Argument[0];MapValue of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableMap;(Map);;Argument[0].MapValue;ReturnValue.MapValue;value;manual",
       Map out = null;
       Object in = storeMapValue(source()); out = ((Collections)null).unmodifiableMap((Map)in); sink(readMapValue(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableList;(List);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableList;(List);;Argument[0].Element;ReturnValue.Element;value;manual",
       List out = null;
       List in = storeElementList(source()); out = ((Collections)null).unmodifiableList(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableNavigableSet;(NavigableSet);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableNavigableSet;(NavigableSet);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       NavigableSet in = storeElementNavSet(source()); out = ((Collections)null).unmodifiableNavigableSet(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableSortedSet;(SortedSet);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableSortedSet;(SortedSet);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       SortedSet in = storeElementNavSet(source()); out = ((Collections)null).unmodifiableSortedSet(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableSet;(Set);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableSet;(Set);;Argument[0].Element;ReturnValue.Element;value;manual",
       Set out = null;
       Set in = storeElementNavSet(source()); out = ((Collections)null).unmodifiableSet(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;unmodifiableCollection;(Collection);;Element of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Collections;false;unmodifiableCollection;(Collection);;Argument[0].Element;ReturnValue.Element;value;manual",
       Collection out = null;
       Collection in = storeElementList(source()); out = ((Collections)null).unmodifiableCollection(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;max;;;Element of Argument[0];ReturnValue;value;manual",
+      // "java.util;Collections;false;max;;;Argument[0].Element;ReturnValue;value;manual",
       Object out = null;
       Collection in = storeElementList(source()); out = ((Collections)null).max(in); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;min;;;Element of Argument[0];ReturnValue;value;manual",
+      // "java.util;Collections;false;min;;;Argument[0].Element;ReturnValue;value;manual",
       Object out = null;
       Collection in = storeElementList(source()); out = ((Collections)null).min(in); sink(out); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(Object[],int,int,Object);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(Object[],int,int,Object);;Argument[3];Argument[0].ArrayElement;value;manual",
       Object[] out = null;
       Object in = source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(Object[],Object);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(Object[],Object);;Argument[1];Argument[0].ArrayElement;value;manual",
       Object[] out = null;
       Object in = source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(float[],int,int,float);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(float[],int,int,float);;Argument[3];Argument[0].ArrayElement;value;manual",
       float[] out = null;
       float in = (Float)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(float[],float);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(float[],float);;Argument[1];Argument[0].ArrayElement;value;manual",
       float[] out = null;
       float in = (Float)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(double[],int,int,double);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(double[],int,int,double);;Argument[3];Argument[0].ArrayElement;value;manual",
       double[] out = null;
       double in = (Double)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(double[],double);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(double[],double);;Argument[1];Argument[0].ArrayElement;value;manual",
       double[] out = null;
       double in = (Double)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(boolean[],int,int,boolean);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(boolean[],int,int,boolean);;Argument[3];Argument[0].ArrayElement;value;manual",
       boolean[] out = null;
       boolean in = (Boolean)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(boolean[],boolean);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(boolean[],boolean);;Argument[1];Argument[0].ArrayElement;value;manual",
       boolean[] out = null;
       boolean in = (Boolean)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(byte[],int,int,byte);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(byte[],int,int,byte);;Argument[3];Argument[0].ArrayElement;value;manual",
       byte[] out = null;
       byte in = (Byte)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(byte[],byte);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(byte[],byte);;Argument[1];Argument[0].ArrayElement;value;manual",
       byte[] out = null;
       byte in = (Byte)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(char[],int,int,char);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(char[],int,int,char);;Argument[3];Argument[0].ArrayElement;value;manual",
       char[] out = null;
       char in = (Character)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(char[],char);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(char[],char);;Argument[1];Argument[0].ArrayElement;value;manual",
       char[] out = null;
       char in = (Character)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(short[],int,int,short);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(short[],int,int,short);;Argument[3];Argument[0].ArrayElement;value;manual",
       short[] out = null;
       short in = (Short)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(short[],short);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(short[],short);;Argument[1];Argument[0].ArrayElement;value;manual",
       short[] out = null;
       short in = (Short)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(int[],int,int,int);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(int[],int,int,int);;Argument[3];Argument[0].ArrayElement;value;manual",
       int[] out = null;
       int in = (Integer)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(int[],int);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(int[],int);;Argument[1];Argument[0].ArrayElement;value;manual",
       int[] out = null;
       int in = (Integer)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(long[],int,int,long);;Argument[3];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(long[],int,int,long);;Argument[3];Argument[0].ArrayElement;value;manual",
       long[] out = null;
       long in = (Long)source(); ((Arrays)null).fill(out,0,0,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;fill;(long[],long);;Argument[1];ArrayElement of Argument[0];value;manual",
+      // "java.util;Arrays;false;fill;(long[],long);;Argument[1];Argument[0].ArrayElement;value;manual",
       long[] out = null;
       long in = (Long)source(); ((Arrays)null).fill(out,in); sink(readArrayElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;replaceAll;(List,Object,Object);;Argument[2];Element of Argument[0];value;manual",
+      // "java.util;Collections;false;replaceAll;(List,Object,Object);;Argument[2];Argument[0].Element;value;manual",
       List out = null;
       Object in = source(); ((Collections)null).replaceAll(out,null,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;copy;(List,List);;Element of Argument[1];Element of Argument[0];value;manual",
+      // "java.util;Collections;false;copy;(List,List);;Argument[1].Element;Argument[0].Element;value;manual",
       List out = null;
       List in = storeElementList(source()); ((Collections)null).copy(out,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;fill;(List,Object);;Argument[1];Element of Argument[0];value;manual",
+      // "java.util;Collections;false;fill;(List,Object);;Argument[1];Argument[0].Element;value;manual",
       List out = null;
       Object in = source(); ((Collections)null).fill(out,in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Arrays;false;asList;;;ArrayElement of Argument[0];Element of ReturnValue;value;manual",
+      // "java.util;Arrays;false;asList;;;Argument[0].ArrayElement;ReturnValue.Element;value;manual",
       List out = null;
       Object[] in = storeArrayElement(source()); out = ((Arrays)null).asList(in); sink(readElement(out)); // $ hasValueFlow
     }
     {
-      // "java.util;Collections;false;addAll;(Collection,Object[]);;ArrayElement of Argument[1];Element of Argument[0];value;manual"
+      // "java.util;Collections;false;addAll;(Collection,Object[]);;Argument[1].ArrayElement;Argument[0].Element;value;manual"
       Collection out = null;
       Object[] in = storeArrayElement(source()); ((Collections)null).addAll(out,in); sink(readElement(out)); // $ hasValueFlow
     }
diff --git a/java/ql/test/query-tests/Metrics/GeneratedVsManualCoverage/TopJdkApisTest/TopJdkApisTest.expected b/java/ql/test/query-tests/Metrics/GeneratedVsManualCoverage/TopJdkApisTest/TopJdkApisTest.expected
index 4fee1c07e06a..a092100b6a74 100644
--- a/java/ql/test/query-tests/Metrics/GeneratedVsManualCoverage/TopJdkApisTest/TopJdkApisTest.expected
+++ b/java/ql/test/query-tests/Metrics/GeneratedVsManualCoverage/TopJdkApisTest/TopJdkApisTest.expected
@@ -13,7 +13,7 @@
 | java.time | 0 | 0 | 0 | 17 | 17 | 0.0 | 0.0 | 0.0 | NaN | NaN | 1.0 |
 | java.time.chrono | 0 | 0 | 0 | 1 | 1 | 0.0 | 0.0 | 0.0 | NaN | NaN | 1.0 |
 | java.time.format | 0 | 0 | 0 | 2 | 2 | 0.0 | 0.0 | 0.0 | NaN | NaN | 1.0 |
-| java.util | 0 | 0 | 84 | 68 | 152 | 0.5526315789473685 | 0.0 | 0.5526315789473685 | 0.0 | NaN | 0.4473684210526316 |
+| java.util | 0 | 0 | 86 | 66 | 152 | 0.5657894736842105 | 0.0 | 0.5657894736842105 | 0.0 | NaN | 0.4342105263157895 |
 | java.util.concurrent | 0 | 0 | 9 | 9 | 18 | 0.5 | 0.0 | 0.5 | 0.0 | NaN | 0.5 |
 | java.util.concurrent.atomic | 0 | 0 | 2 | 11 | 13 | 0.15384615384615385 | 0.0 | 0.15384615384615385 | 0.0 | NaN | 0.8461538461538461 |
 | java.util.concurrent.locks | 0 | 0 | 0 | 2 | 2 | 0.0 | 0.0 | 0.0 | NaN | NaN | 1.0 |