WIP

nullaway/src/main/java/com/uber/nullaway/NullabilityUtil.java

@@ -730,4 +730,31 @@ public static ExpressionTree stripParensAndCasts(ExpressionTree expr) {
     }
     return expr;
   }
+
+  public record ExprTreeAndState(ExpressionTree expr, VisitorState state) {}
+
+  /**
+   * strip out enclosing parentheses, and update the tree path in the VisitorState to point to the
+   * stripped expression if the original expression was the leaf of the path
+   *
+   * @param expr a potentially parenthesised expression.
+   * @param state the VisitorState
+   * @return the same expression without parentheses, and the updated VisitorState
+   */
+  public static ExprTreeAndState stripParensAndUpdateTreePath(
+      ExpressionTree expr, VisitorState state) {
+    TreePath path = state.getPath();
+    if (path.getLeaf() != expr) {
+      // if the expression is not the leaf of the path, we can't update the path to point to the
+      // stripped expression, so we just return the original expression and state
+      return new ExprTreeAndState(expr, state);
+    }
+    ExpressionTree resultExpr = expr;
+    while (resultExpr instanceof ParenthesizedTree) {
+      resultExpr = ((ParenthesizedTree) resultExpr).getExpression();
+      path = new TreePath(path, resultExpr);
+    }
+    VisitorState resultState = path == state.getPath() ? state : state.withPath(path);
+    return new ExprTreeAndState(resultExpr, resultState);
+  }
 }

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

@@ -28,7 +28,6 @@
 import com.sun.source.tree.Tree;
 import com.sun.source.tree.VariableTree;
 import com.sun.source.util.TreePath;
-import com.sun.source.util.TreePathScanner;
 import com.sun.source.util.TreeScanner;
 import com.sun.tools.javac.code.Attribute;
 import com.sun.tools.javac.code.Symbol;
@@ -425,7 +424,12 @@ private void reportInvalidOverridingMethodParamTypeError(
    * @return Type of the tree with preserved annotations.
    */
   private @Nullable Type getTreeType(Tree tree, VisitorState state) {
-    tree = ASTHelpers.stripParentheses(tree);
+    if (tree instanceof ExpressionTree exprTree) {
+      NullabilityUtil.ExprTreeAndState exprTreeAndState =
+          NullabilityUtil.stripParensAndUpdateTreePath(exprTree, state);
+      tree = exprTreeAndState.expr();
+      state = exprTreeAndState.state();
+    }
     if (tree instanceof LambdaExpressionTree || tree instanceof MemberReferenceTree) {
       Type result = inferredPolyExpressionTypes.get(tree);
       if (result == null) {
@@ -545,10 +549,10 @@ private void reportInvalidOverridingMethodParamTypeError(
    * available.
    */
   private @Nullable Type getDiamondTypeFromContext(NewClassTree tree, VisitorState state) {
-    TreePath treePath = findPathToSubtree(state.getPath(), tree);
-    if (treePath == null) {
-      return null;
-    }
+    TreePath treePath = state.getPath();
+    //    if (treePath == null) {
+    //      return null;
+    //    }
     return getDiamondTypeFromParentContext(tree, state, castToNonNull(treePath.getParentPath()));
   }
 
@@ -629,28 +633,28 @@ private void reportInvalidOverridingMethodParamTypeError(
   }
 
   /** Finds the path to {@code target} within {@code rootPath}, or null when not found. */
-  private static @Nullable TreePath findPathToSubtree(TreePath rootPath, Tree target) {
-    if (rootPath.getLeaf() == target) {
-      return rootPath;
-    }
-    return new TreePathScanner<@Nullable TreePath, @Nullable TreePath>() {
-      @Override
-      public @Nullable TreePath scan(Tree tree, @Nullable TreePath prevPath) {
-        if (tree == target) {
-          // When overriding scan(), getCurrentPath() still points at the parent.
-          return new TreePath(getCurrentPath(), tree);
-        }
-        return super.scan(tree, null);
-      }
-
-      @Override
-      public @Nullable TreePath reduce(@Nullable TreePath r1, @Nullable TreePath r2) {
-        // we should only find the target once, so at most one of r1 and r2 should be non-null
-        Verify.verify(r1 == null || r2 == null);
-        return r1 != null ? r1 : r2;
-      }
-    }.scan(rootPath, null);
-  }
+  //  private static @Nullable TreePath findPathToSubtree(TreePath rootPath, Tree target) {
+  //    if (rootPath.getLeaf() == target) {
+  //      return rootPath;
+  //    }
+  //    return new TreePathScanner<@Nullable TreePath, @Nullable TreePath>() {
+  //      @Override
+  //      public @Nullable TreePath scan(Tree tree, @Nullable TreePath prevPath) {
+  //        if (tree == target) {
+  //          // When overriding scan(), getCurrentPath() still points at the parent.
+  //          return new TreePath(getCurrentPath(), tree);
+  //        }
+  //        return super.scan(tree, null);
+  //      }
+  //
+  //      @Override
+  //      public @Nullable TreePath reduce(@Nullable TreePath r1, @Nullable TreePath r2) {
+  //        // we should only find the target once, so at most one of r1 and r2 should be non-null
+  //        Verify.verify(r1 == null || r2 == null);
+  //        return r1 != null ? r1 : r2;
+  //      }
+  //    }.scan(rootPath, null);
+  //  }
 
   /**
    * Returns true when javac inferred class type arguments for a constructor call, i.e. there are
@@ -753,7 +757,8 @@ public void checkTypeParameterNullnessForAssignability(Tree tree, VisitorState s
         && isAssignmentToField(tree)) {
       maybeStoreLambdaTypeFromTarget(lambdaExpressionTree, lhsType);
     }
-    Type rhsType = getTreeType(rhsTree, state);
+    TreePath pathToRhs = new TreePath(state.getPath(), rhsTree);
+    Type rhsType = getTreeType(rhsTree, state.withPath(pathToRhs));
     if (rhsType != null) {
       if (isGenericCallNeedingInference(rhsTree)) {
         rhsType =