Use .equals() for nodeValues if == does not work; fixes #3484

checker/tests/nullness/TryCatch.java

@@ -22,7 +22,6 @@ void unreachableCatch(String[] xs) {
         t.toString();
         try {
         } catch (Throwable e) {
-            // :: error: (dereference.of.nullable)
             t.toString();
         }
     }

dataflow/src/main/java/org/checkerframework/dataflow/analysis/AnalysisResult.java

@@ -2,11 +2,13 @@
 
 import com.sun.source.tree.Tree;
 import com.sun.source.tree.UnaryTree;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.StringJoiner;
 import javax.lang.model.element.Element;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.dataflow.cfg.block.Block;
@@ -166,7 +168,24 @@ public HashMap<Element, V> getFinalLocalValues() {
      *     available
      */
     public @Nullable V getValue(Node n) {
-        return nodeValues.get(n);
+        V result = nodeValues.get(n);
+        if (result != null) {
+            return result;
+        }
+        List<Node> equalNodes = new ArrayList<>();
+        for (Node candidate : nodeValues.keySet()) {
+            if (n.equals(candidate)) {
+                equalNodes.add(candidate);
+            }
+        }
+        switch (equalNodes.size()) {
+            case 0:
+                return null;
+            case 1:
+                return nodeValues.get(equalNodes.get(0));
+            default:
+                return null;
+        }
     }
 
     /**
@@ -443,4 +462,83 @@ public static <V extends AbstractValue<V>, S extends Store<S>> S runAnalysisFor(
         return transferInput.analysis.runAnalysisFor(
                 node, before, transferInput, nodeValues, analysisCaches);
     }
+
+    /**
+     * Returns a verbose string representation of this, useful for debugging.
+     *
+     * @return a string representation of this
+     */
+    public String repr() {
+        StringJoiner result =
+                new StringJoiner(
+                        String.format("%n  "),
+                        String.format("AnalysisResult{%n  "),
+                        String.format("%n}"));
+        result.add("nodeValues = " + nodeValuesRepr(nodeValues));
+        result.add("treeLookup = " + treeLookupRepr(treeLookup));
+        result.add("unaryAssignNodeLookup = " + unaryAssignNodeLookup);
+        result.add("finalLocalValues = " + finalLocalValues);
+        result.add("stores = " + stores);
+        result.add("analysisCaches = " + analysisCaches);
+        return result.toString();
+    }
+
+    /**
+     * Returns a verbose printed representation, useful for debugging. The map has the same type as
+     * the {@code nodeValues} field.
+     *
+     * @param <V> the type of values in the map
+     * @param nodeValues a map to format
+     * @return a printed representation of the given map
+     */
+    public static <V> String nodeValuesRepr(Map<Node, V> nodeValues) {
+        if (nodeValues.isEmpty()) {
+            return "{}";
+        }
+        StringJoiner result = new StringJoiner(String.format("%n    "));
+        result.add("{");
+        for (Map.Entry<Node, V> entry : nodeValues.entrySet()) {
+            Node key = entry.getKey();
+            result.add(String.format("%s => %s", key.repr(), entry.getValue()));
+        }
+        result.add("}");
+        return result.toString();
+    }
+
+    /**
+     * Returns a verbose printed representation of a map, useful for debugging. The map has the same
+     * type as the {@code treeLookup} field.
+     *
+     * @param treeLookup a map to format
+     * @return a printed representation of the given map
+     */
+    public static String treeLookupRepr(Map<Tree, Set<Node>> treeLookup) {
+        if (treeLookup.isEmpty()) {
+            return "{}";
+        }
+        StringJoiner result = new StringJoiner(String.format("%n    "));
+        result.add("{");
+        for (Map.Entry<Tree, Set<Node>> entry : treeLookup.entrySet()) {
+            Tree key = entry.getKey();
+            String treeString = key.toString().replaceAll("[ \n\t]+", " ");
+            if (treeString.length() > 65) {
+                treeString = "\"" + treeString.substring(0, 60) + "...\"";
+            }
+            result.add(treeString + " => " + Node.nodeCollectionRepr(entry.getValue()));
+        }
+        result.add("}");
+        return result.toString();
+    }
+
+    /** Checks representation invariants on this. */
+    public void checkRep() {
+        // Require that each node in treeLookup exists in nodeValues.
+        for (Map.Entry<Tree, Set<Node>> entry : treeLookup.entrySet()) {
+            for (Node n : entry.getValue()) {
+                if (!nodeValues.containsKey(n)) {
+                    throw new BugInCF("node %s is in treeLookup but not in nodeValues", n);
+                }
+            }
+        }
+    }
 }

dataflow/src/main/java/org/checkerframework/dataflow/cfg/ControlFlowGraph.java

@@ -16,7 +16,9 @@
 import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
+import java.util.StringJoiner;
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.checkerframework.dataflow.analysis.AnalysisResult;
 import org.checkerframework.dataflow.cfg.block.Block;
 import org.checkerframework.dataflow.cfg.block.Block.BlockType;
 import org.checkerframework.dataflow.cfg.block.ConditionalBlock;
@@ -243,7 +245,8 @@ private Deque<Block> getSuccessors(Block cur) {
     }
 
     /**
-     * Returns the copied tree-lookup map.
+     * Returns the copied tree-lookup map. Ignores convertedTreeLookup, though {@link
+     * #getNodesCorrespondingToTree} uses that field.
      *
      * @return the copied tree-lookup map
      */
@@ -311,4 +314,32 @@ public String toString() {
         String stringGraph = (String) res.get("stringGraph");
         return stringGraph == null ? super.toString() : stringGraph;
     }
+
+    /**
+     * Returns a verbose string representation of this, useful for debugging.
+     *
+     * @return a string representation of this
+     */
+    public String repr() {
+        StringJoiner result =
+                new StringJoiner(
+                        String.format("%n  "),
+                        String.format("ControlFlowGraph{%n  "),
+                        String.format("%n  }"));
+        result.add("entryBlock=" + entryBlock);
+        result.add("regularExitBlock=" + regularExitBlock);
+        result.add("exceptionalExitBlock=" + exceptionalExitBlock);
+        String astString = underlyingAST.toString().replaceAll("[ \t\n]", " ");
+        if (astString.length() > 65) {
+            astString = "\"" + astString.substring(0, 60) + "\"";
+        }
+        result.add("underlyingAST=" + underlyingAST);
+        result.add("treeLookup=" + AnalysisResult.treeLookupRepr(treeLookup));
+        result.add("convertedTreeLookup=" + AnalysisResult.treeLookupRepr(convertedTreeLookup));
+        result.add("unaryAssignNodeLookup=" + unaryAssignNodeLookup);
+        result.add("returnNodes=" + Node.nodeCollectionRepr(returnNodes));
+        result.add("declaredClasses=" + declaredClasses);
+        result.add("declaredLambdas=" + declaredLambdas);
+        return result.toString();
+    }
 }

dataflow/src/main/java/org/checkerframework/dataflow/cfg/node/Node.java

@@ -3,6 +3,7 @@
 import com.sun.source.tree.Tree;
 import java.util.ArrayDeque;
 import java.util.Collection;
+import java.util.StringJoiner;
 import javax.lang.model.type.TypeMirror;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.dataflow.cfg.CFGBuilder;
@@ -157,4 +158,32 @@ public Collection<Node> getTransitiveOperands() {
         }
         return transitiveOperands;
     }
+
+    /**
+     * Returns a verbose printed representation of this, useful for debugging.
+     *
+     * @return a printed representation of this
+     */
+    public String repr() {
+        return String.format(
+                "%s [%s %s %s]",
+                this,
+                this.getClass().getSimpleName(),
+                this.hashCode(),
+                System.identityHashCode(this));
+    }
+
+    /**
+     * Returns a verbose printed representation of a collection of nodes, useful for debugging..
+     *
+     * @param nodes a collection of nodes to format
+     * @return a printed representation of the given collection
+     */
+    public static String nodeCollectionRepr(Collection<? extends Node> nodes) {
+        StringJoiner result = new StringJoiner(", ", "[", "]");
+        for (Node n : nodes) {
+            result.add(n.repr());
+        }
+        return result.toString();
+    }
 }

docs/developer/developer-manual.html

@@ -26,7 +26,10 @@ <h1 id="Checker_Framework_developer_manual">Checker Framework developer manual</
       <li><a href="#Directory_structure">Directory structure</a></li>
       <li><a href="#Build_tasks">Build tasks</a></li>
       <li><a href="#tests">Testing the Checker Framework</a></li>
-      <li><a href="#Code_style">Code style</a></li>
+      <li><a href="#Code_style">Code style</a>
+        <ul>
+          <li><a href="#repr_method">The <code>repr()</code> method</a></li>
+        </ul></li>
       <li><a href="#IDE_configuration">IDE configuration</a></li>
       <li><a href="#pull-requests">Pull requests</a>
         <ul>
@@ -158,6 +161,19 @@ <h2 id="Code_style">Code style</h2>
 </p>
 
 
+<h3 id="repr_method">The <code>repr()</code> method</h3>
+
+<p>
+  Some classes contain a <code>repr()</code> method, for use during
+  debugging or logging.  It returns a string that shows the internal
+  representation of the receiver.  It is like <code>toString()</code> in
+  that it returns a string, but its result gives lower-level, and more
+  verbose details.  A client of the class can decide whether to see the
+  more concise and high-level <code>toString()</code> or the more verbose
+  and low-level <code>repr()</code>, or both.
+</p>
+
+
 <h2 id="IDE_configuration">IDE configuration</h2>
 
 <p>