Methods that take a node as parameter now take type N instead of Object.

[]

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=151580804

guava-tests/test/com/google/common/graph/AbstractGraphTest.java

@@ -131,8 +131,6 @@ static <N> void validateGraph(Graph<N> graph) {
 
     for (N node : sanityCheckSet(graph.nodes())) {
       assertThat(nodeString).contains(node.toString());
-      assertThat(graph.hasEdge(node, new Object())).isFalse();
-      assertThat(graph.hasEdge(new Object(), node)).isFalse();
 
       if (graph.isDirected()) {
         assertThat(graph.degree(node)).isEqualTo(graph.inDegree(node) + graph.outDegree(node));
@@ -170,7 +168,6 @@ static <N> void validateGraph(Graph<N> graph) {
     }
 
     sanityCheckSet(graph.edges());
-    assertThat(graph.hasEdge(new Object(), new Object())).isFalse();
     assertThat(graph.edges()).doesNotContain(EndpointPair.of(graph, new Object(), new Object()));
     assertThat(graph.edges()).isEqualTo(allEndpointPairs);
   }

guava/src/com/google/common/graph/AbstractBaseGraph.java

@@ -66,6 +66,10 @@ public int size() {
         return Ints.saturatedCast(edgeCount());
       }
 
+      // Mostly safe: We check contains(u) before calling successors(u), so we perform unsafe
+      // operations only in weird cases like checking for an EndpointPair<ArrayList> in a
+      // Graph<LinkedList>.
+      @SuppressWarnings("unchecked")
       @Override
       public boolean contains(@Nullable Object obj) {
         if (!(obj instanceof EndpointPair)) {
@@ -74,13 +78,13 @@ public boolean contains(@Nullable Object obj) {
         EndpointPair<?> endpointPair = (EndpointPair<?>) obj;
         return isDirected() == endpointPair.isOrdered()
             && nodes().contains(endpointPair.nodeU())
-            && successors(endpointPair.nodeU()).contains(endpointPair.nodeV());
+            && successors((N) endpointPair.nodeU()).contains(endpointPair.nodeV());
       }
     };
   }
 
   @Override
-  public int degree(Object node) {
+  public int degree(N node) {
     if (isDirected()) {
       return IntMath.saturatedAdd(predecessors(node).size(), successors(node).size());
     } else {
@@ -91,17 +95,17 @@ public int degree(Object node) {
   }
 
   @Override
-  public int inDegree(Object node) {
+  public int inDegree(N node) {
     return isDirected() ? predecessors(node).size() : degree(node);
   }
 
   @Override
-  public int outDegree(Object node) {
+  public int outDegree(N node) {
     return isDirected() ? successors(node).size() : degree(node);
   }
 
   @Override
-  public boolean hasEdge(Object nodeU, Object nodeV) {
+  public boolean hasEdge(N nodeU, N nodeV) {
     checkNotNull(nodeU);
     checkNotNull(nodeV);
     return nodes().contains(nodeU) && successors(nodeU).contains(nodeV);

guava/src/com/google/common/graph/AbstractNetwork.java

@@ -78,6 +78,10 @@ public int size() {
             return AbstractNetwork.this.edges().size();
           }
 
+          // Mostly safe: We check contains(u) before calling successors(u), so we perform unsafe
+          // operations only in weird cases like checking for an EndpointPair<ArrayList> in a
+          // Network<LinkedList>.
+          @SuppressWarnings("unchecked")
           @Override
           public boolean contains(@Nullable Object obj) {
             if (!(obj instanceof EndpointPair)) {
@@ -86,7 +90,7 @@ public boolean contains(@Nullable Object obj) {
             EndpointPair<?> endpointPair = (EndpointPair<?>) obj;
             return isDirected() == endpointPair.isOrdered()
                 && nodes().contains(endpointPair.nodeU())
-                && successors(endpointPair.nodeU()).contains(endpointPair.nodeV());
+                && successors((N) endpointPair.nodeU()).contains(endpointPair.nodeV());
           }
         };
       }
@@ -107,17 +111,17 @@ public boolean allowsSelfLoops() {
       }
 
       @Override
-      public Set<N> adjacentNodes(Object node) {
+      public Set<N> adjacentNodes(N node) {
         return AbstractNetwork.this.adjacentNodes(node);
       }
 
       @Override
-      public Set<N> predecessors(Object node) {
+      public Set<N> predecessors(N node) {
         return AbstractNetwork.this.predecessors(node);
       }
 
       @Override
-      public Set<N> successors(Object node) {
+      public Set<N> successors(N node) {
         return AbstractNetwork.this.successors(node);
       }
 
@@ -126,7 +130,7 @@ public Set<N> successors(Object node) {
   }
 
   @Override
-  public int degree(Object node) {
+  public int degree(N node) {
     if (isDirected()) {
       return IntMath.saturatedAdd(inEdges(node).size(), outEdges(node).size());
     } else {
@@ -135,25 +139,25 @@ public int degree(Object node) {
   }
 
   @Override
-  public int inDegree(Object node) {
+  public int inDegree(N node) {
     return isDirected() ? inEdges(node).size() : degree(node);
   }
 
   @Override
-  public int outDegree(Object node) {
+  public int outDegree(N node) {
     return isDirected() ? outEdges(node).size() : degree(node);
   }
 
   @Override
   public Set<E> adjacentEdges(Object edge) {
-    EndpointPair<?> endpointPair = incidentNodes(edge); // Verifies that edge is in this network.
+    EndpointPair<N> endpointPair = incidentNodes(edge); // Verifies that edge is in this network.
     Set<E> endpointPairIncidentEdges =
         Sets.union(incidentEdges(endpointPair.nodeU()), incidentEdges(endpointPair.nodeV()));
     return Sets.difference(endpointPairIncidentEdges, ImmutableSet.of(edge));
   }
 
   @Override
-  public Optional<E> edgeConnecting(Object nodeU, Object nodeV) {
+  public Optional<E> edgeConnecting(N nodeU, N nodeV) {
     Set<E> edgesConnecting = edgesConnecting(nodeU, nodeV);
     switch (edgesConnecting.size()) {
       case 0:

guava/src/com/google/common/graph/AbstractValueGraph.java

@@ -70,39 +70,39 @@ public ElementOrder<N> nodeOrder() {
       }
 
       @Override
-      public Set<N> adjacentNodes(Object node) {
+      public Set<N> adjacentNodes(N node) {
         return AbstractValueGraph.this.adjacentNodes(node);
       }
 
       @Override
-      public Set<N> predecessors(Object node) {
+      public Set<N> predecessors(N node) {
         return AbstractValueGraph.this.predecessors(node);
       }
 
       @Override
-      public Set<N> successors(Object node) {
+      public Set<N> successors(N node) {
         return AbstractValueGraph.this.successors(node);
       }
 
       @Override
-      public int degree(Object node) {
+      public int degree(N node) {
         return AbstractValueGraph.this.degree(node);
       }
 
       @Override
-      public int inDegree(Object node) {
+      public int inDegree(N node) {
         return AbstractValueGraph.this.inDegree(node);
       }
 
       @Override
-      public int outDegree(Object node) {
+      public int outDegree(N node) {
         return AbstractValueGraph.this.outDegree(node);
       }
     };
   }
 
   @Override
-  public V edgeValue(Object nodeU, Object nodeV) {
+  public V edgeValue(N nodeU, N nodeV) {
     V value = edgeValueOrDefault(nodeU, nodeV, null);
     if (value == null) {
       checkArgument(nodes().contains(nodeU), NODE_NOT_IN_GRAPH, nodeU);

guava/src/com/google/common/graph/BaseGraph.java

@@ -16,7 +16,6 @@
 
 package com.google.common.graph;
 
-import com.google.errorprone.annotations.CompatibleWith;
 import java.util.Set;
 
 /**
@@ -66,7 +65,7 @@ interface BaseGraph<N> extends SuccessorsFunction<N>, PredecessorsFunction<N> {
    *
    * @throws IllegalArgumentException if {@code node} is not an element of this graph
    */
-  Set<N> adjacentNodes(@CompatibleWith("N") Object node);
+  Set<N> adjacentNodes(N node);
 
   /**
    * Returns all nodes in this graph adjacent to {@code node} which can be reached by traversing
@@ -77,7 +76,7 @@ interface BaseGraph<N> extends SuccessorsFunction<N>, PredecessorsFunction<N> {
    * @throws IllegalArgumentException if {@code node} is not an element of this graph
    */
   @Override
-  Set<N> predecessors(Object node);
+  Set<N> predecessors(N node);
 
   /**
    * Returns all nodes in this graph adjacent to {@code node} which can be reached by traversing
@@ -91,7 +90,7 @@ interface BaseGraph<N> extends SuccessorsFunction<N>, PredecessorsFunction<N> {
    * @throws IllegalArgumentException if {@code node} is not an element of this graph
    */
   @Override
-  Set<N> successors(Object node);
+  Set<N> successors(N node);
 
   /**
    * Returns the count of {@code node}'s incident edges, counting self-loops twice (equivalently,
@@ -106,7 +105,7 @@ interface BaseGraph<N> extends SuccessorsFunction<N>, PredecessorsFunction<N> {
    *
    * @throws IllegalArgumentException if {@code node} is not an element of this graph
    */
-  int degree(@CompatibleWith("N") Object node);
+  int degree(N node);
 
   /**
    * Returns the count of {@code node}'s incoming edges (equal to {@code predecessors(node).size()})
@@ -116,7 +115,7 @@ interface BaseGraph<N> extends SuccessorsFunction<N>, PredecessorsFunction<N> {
    *
    * @throws IllegalArgumentException if {@code node} is not an element of this graph
    */
-  int inDegree(@CompatibleWith("N") Object node);
+  int inDegree(N node);
 
   /**
    * Returns the count of {@code node}'s outgoing edges (equal to {@code successors(node).size()})
@@ -126,13 +125,13 @@ interface BaseGraph<N> extends SuccessorsFunction<N>, PredecessorsFunction<N> {
    *
    * @throws IllegalArgumentException if {@code node} is not an element of this graph
    */
-  int outDegree(@CompatibleWith("N") Object node);
+  int outDegree(N node);
 
   /**
    * Returns true if there is an edge directly connecting {@code nodeU} to {@code nodeV}. This is
    * equivalent to {@code return nodes().contains(nodeU) && successors(nodeU).contains(nodeV)}.
    *
    * <p>In an undirected graph, this is equal to {@code hasEdge(nodeV, nodeU)}.
    */
-  boolean hasEdge(@CompatibleWith("N") Object nodeU, @CompatibleWith("N") Object nodeV);
+  boolean hasEdge(N nodeU, N nodeV);
 }

guava/src/com/google/common/graph/ConfigurableMutableGraph.java

@@ -52,12 +52,12 @@ public boolean putEdge(N nodeU, N nodeV) {
   }
 
   @Override
-  public boolean removeNode(Object node) {
+  public boolean removeNode(N node) {
     return backingValueGraph.removeNode(node);
   }
 
   @Override
-  public boolean removeEdge(Object nodeU, Object nodeV) {
+  public boolean removeEdge(N nodeU, N nodeV) {
     return backingValueGraph.removeEdge(nodeU, nodeV) != null;
   }
 }

guava/src/com/google/common/graph/ConfigurableMutableNetwork.java

@@ -118,7 +118,7 @@ public boolean addEdge(N nodeU, N nodeV, E edge) {
 
   @Override
   @CanIgnoreReturnValue
-  public boolean removeNode(Object node) {
+  public boolean removeNode(N node) {
     checkNotNull(node, "node");
 
     NetworkConnections<N, E> connections = nodeConnections.get(node);

guava/src/com/google/common/graph/ConfigurableMutableValueGraph.java

@@ -100,7 +100,7 @@ public V putEdgeValue(N nodeU, N nodeV, V value) {
 
   @Override
   @CanIgnoreReturnValue
-  public boolean removeNode(Object node) {
+  public boolean removeNode(N node) {
     checkNotNull(node, "node");
 
     GraphConnections<N, V> connections = nodeConnections.get(node);
@@ -133,7 +133,7 @@ public boolean removeNode(Object node) {
 
   @Override
   @CanIgnoreReturnValue
-  public V removeEdge(Object nodeU, Object nodeV) {
+  public V removeEdge(N nodeU, N nodeV) {
     checkNotNull(nodeU, "nodeU");
     checkNotNull(nodeV, "nodeV");
 

guava/src/com/google/common/graph/ConfigurableNetwork.java

@@ -128,7 +128,7 @@ public ElementOrder<E> edgeOrder() {
   }
 
   @Override
-  public Set<E> incidentEdges(Object node) {
+  public Set<E> incidentEdges(N node) {
     return checkedConnections(node).incidentEdges();
   }
 
@@ -140,12 +140,12 @@ public EndpointPair<N> incidentNodes(Object edge) {
   }
 
   @Override
-  public Set<N> adjacentNodes(Object node) {
+  public Set<N> adjacentNodes(N node) {
     return checkedConnections(node).adjacentNodes();
   }
 
   @Override
-  public Set<E> edgesConnecting(Object nodeU, Object nodeV) {
+  public Set<E> edgesConnecting(N nodeU, N nodeV) {
     NetworkConnections<N, E> connectionsU = checkedConnections(nodeU);
     if (!allowsSelfLoops && nodeU == nodeV) { // just an optimization, only check reference equality
       return ImmutableSet.of();
@@ -155,22 +155,22 @@ public Set<E> edgesConnecting(Object nodeU, Object nodeV) {
   }
 
   @Override
-  public Set<E> inEdges(Object node) {
+  public Set<E> inEdges(N node) {
     return checkedConnections(node).inEdges();
   }
 
   @Override
-  public Set<E> outEdges(Object node) {
+  public Set<E> outEdges(N node) {
     return checkedConnections(node).outEdges();
   }
 
   @Override
-  public Set<N> predecessors(Object node) {
+  public Set<N> predecessors(N node) {
     return checkedConnections(node).predecessors();
   }
 
   @Override
-  public Set<N> successors(Object node) {
+  public Set<N> successors(N node) {
     return checkedConnections(node).successors();
   }