get rid of withPathToSubtree

nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java

@@ -652,20 +652,6 @@ private void reportInvalidOverridingMethodParamTypeError(
     }.scan(rootPath, null);
   }
 
-  /**
-   * Creates a state whose path points to {@code subtree}, when that subtree is reachable.
-   *
-   * @param state the original state with a path to some subtree of the AST
-   * @param subtree the subtree to find within the original state's path
-   * @return a state with the same information as the original, but with a path to {@code subtree}
-   *     if it is reachable from the original state's path, or the original state if {@code subtree}
-   *     is not reachable
-   */
-  private static VisitorState withPathToSubtree(VisitorState state, Tree subtree) {
-    TreePath subtreePath = findPathToSubtree(state.getPath(), subtree);
-    return subtreePath == null ? state : state.withPath(subtreePath);
-  }
-
   /**
    * Returns true when javac inferred class type arguments for a constructor call, i.e. there are
    * instantiated type arguments at the type level, but no explicit non-diamond source type args.
@@ -767,7 +753,7 @@ public void checkTypeParameterNullnessForAssignability(Tree tree, VisitorState s
         && isAssignmentToField(tree)) {
       maybeStoreLambdaTypeFromTarget(lambdaExpressionTree, lhsType);
     }
-    Type rhsType = getTreeType(rhsTree, withPathToSubtree(state, rhsTree));
+    Type rhsType = getTreeType(rhsTree, state);
     if (rhsType != null) {
       if (isGenericCallNeedingInference(rhsTree)) {
         rhsType =
@@ -1490,7 +1476,7 @@ public void checkTypeParameterNullnessForFunctionReturnType(
       // bail out of any checking involving raw types for now
       return;
     }
-    Type returnExpressionType = getTreeType(retExpr, withPathToSubtree(state, retExpr));
+    Type returnExpressionType = getTreeType(retExpr, state);
     if (returnExpressionType != null) {
       if (isGenericCallNeedingInference(retExpr)) {
         returnExpressionType =
@@ -1685,8 +1671,7 @@ public void compareGenericTypeParameterNullabilityForCall(
               if (inferredPolyType != null) {
                 actualParameterType = inferredPolyType;
               } else {
-                actualParameterType =
-                    getTreeType(currentActualParam, withPathToSubtree(state, currentActualParam));
+                actualParameterType = getTreeType(currentActualParam, state);
               }
               if (actualParameterType != null) {
                 if (isGenericCallNeedingInference(currentActualParam)) {
@@ -2207,14 +2192,14 @@ public Nullness getGenericParameterNullnessAtInvocation(
                   false,
                   calledFromDataflow);
         } else {
-          enclosingType = getTreeType(receiver, withPathToSubtree(state, receiver));
+          enclosingType = getTreeType(receiver, state);
         }
       }
     } else {
       Verify.verify(tree instanceof NewClassTree);
       // for a constructor invocation, the type from the invocation itself is the "enclosing type"
       // for the purposes of determining type arguments
-      enclosingType = getTreeType(tree, withPathToSubtree(state, tree));
+      enclosingType = getTreeType(tree, state);
     }
     return enclosingType;
   }