Minor cleanup, no behavior changes (#1487)

Cleanup a few things I noticed while browsing the source. No logic
changes.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **Refactor**
* Simplified conditional logic across multiple core modules to reduce
nesting and improve readability.
* Modernized type handling with newer language constructs to remove
unnecessary casts and streamline control flow.
* Consistent generic initialization improvements for clearer, more
concise code.

* **Style**
* Minor null-safety and stylistic updates to improve robustness and
maintainability.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Co-authored-by: Manu Sridharan <msridhar@gmail.com>

Author: armandino

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

@@ -58,6 +58,7 @@
 import com.uber.nullaway.fixserialization.SerializationService;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.StreamSupport;
 import javax.lang.model.element.Element;
@@ -178,8 +179,8 @@ private static boolean canHaveSuppressWarningsAnnotation(Tree tree) {
   private boolean hasPathSuppression(TreePath treePath, String subcheckerName) {
     return StreamSupport.stream(treePath.spliterator(), false)
         .filter(ErrorBuilder::canHaveSuppressWarningsAnnotation)
-        .map(tree -> ASTHelpers.getSymbol(tree))
-        .filter(symbol -> symbol != null)
+        .map(ASTHelpers::getSymbol)
+        .filter(Objects::nonNull)
         .anyMatch(
             symbol ->
                 symbolHasSuppressWarningsAnnotation(symbol, subcheckerName)

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

@@ -1580,10 +1580,8 @@ private ImmutableMultimap<Tree, Element> computeTree2Init(
               nullnessAnalysis.getNonnullFieldsOfReceiverAtExit(memberPath, state.context));
         }
       }
-      if (memberTree instanceof MethodTree methodTree) {
-        if (isConstructor(methodTree)) {
-          constructors.add(methodTree);
-        }
+      if (memberTree instanceof MethodTree methodTree && isConstructor(methodTree)) {
+        constructors.add(methodTree);
       }
     }
     // all the initializer blocks have run before any code inside a constructor
@@ -2476,14 +2474,12 @@ private Set<Element> getSafeInitMethods(
       // as "top level" for the purposes of finding initialization methods. Any exception happening
       // there is also an
       // exception of the full method.
-      if (stmt instanceof TryTree tryTree) {
-        if (tryTree.getCatches().isEmpty()) {
-          if (tryTree.getBlock() != null) {
-            result.addAll(getSafeInitMethods(tryTree.getBlock(), classSymbol, state));
-          }
-          if (tryTree.getFinallyBlock() != null) {
-            result.addAll(getSafeInitMethods(tryTree.getFinallyBlock(), classSymbol, state));
-          }
+      if (stmt instanceof TryTree tryTree && tryTree.getCatches().isEmpty()) {
+        if (tryTree.getBlock() != null) {
+          result.addAll(getSafeInitMethods(tryTree.getBlock(), classSymbol, state));
+        }
+        if (tryTree.getFinallyBlock() != null) {
+          result.addAll(getSafeInitMethods(tryTree.getFinallyBlock(), classSymbol, state));
         }
       }
     }

nullaway/src/main/java/com/uber/nullaway/dataflow/AccessPath.java

@@ -267,17 +267,17 @@ static AccessPath switchRoot(AccessPath origAP, Element newRoot) {
   }
 
   private static Node stripCasts(Node node) {
-    while (node instanceof TypeCastNode) {
-      node = ((TypeCastNode) node).getOperand();
+    while (node instanceof TypeCastNode typeCastNode) {
+      node = typeCastNode.getOperand();
     }
     return node;
   }
 
   private static @Nullable MapKey argumentToMapKeySpecifier(
       Node argument, VisitorState state, AccessPathContext apContext) {
     // Required to have Node type match Tree type in some instances.
-    if (argument instanceof WideningConversionNode) {
-      argument = ((WideningConversionNode) argument).getOperand();
+    if (argument instanceof WideningConversionNode node) {
+      argument = node.getOperand();
     }
     // A switch at the Tree level should be faster than multiple if checks at the Node level.
     switch (castToNonNull(argument.getTree()).getKind()) {
@@ -456,9 +456,8 @@ private static boolean isBoxingMethod(Symbol.MethodSymbol methodSymbol) {
           Tree tree = argumentNode.getTree();
           if (tree == null) {
             return null; // Not an AP
-          } else if (tree instanceof MethodInvocationTree) {
+          } else if (tree instanceof MethodInvocationTree methodInvocationTree) {
             // Check for boxing call
-            MethodInvocationTree methodInvocationTree = (MethodInvocationTree) tree;
             if (methodInvocationTree.getArguments().size() == 1
                 && isBoxingMethod(ASTHelpers.getSymbol(methodInvocationTree))) {
               tree = methodInvocationTree.getArguments().get(0);
@@ -561,8 +560,7 @@ && isBoxingMethod(ASTHelpers.getSymbol(methodInvocationTree))) {
    */
   public static @Nullable AccessPath mapWithIteratorContentsKey(
       Node mapNode, LocalVariableNode iterVar, AccessPathContext apContext) {
-    IteratorContentsKey iterContentsKey =
-        new IteratorContentsKey((VariableElement) iterVar.getElement());
+    IteratorContentsKey iterContentsKey = new IteratorContentsKey(iterVar.getElement());
     return buildAccessPathRecursive(mapNode, new ArrayDeque<>(), apContext, iterContentsKey);
   }
 

nullaway/src/main/java/com/uber/nullaway/dataflow/DataFlow.java

@@ -94,24 +94,21 @@ public final class DataFlow {
       CacheBuilder.newBuilder()
           .maximumSize(MAX_CACHE_SIZE)
           .build(
-              new CacheLoader<CfgParams, ControlFlowGraph>() {
+              new CacheLoader<>() {
                 @Override
                 public ControlFlowGraph load(CfgParams key) {
                   TreePath codePath = key.codePath();
                   TreePath bodyPath;
                   UnderlyingAST ast;
                   ProcessingEnvironment env = key.environment();
-                  if (codePath.getLeaf() instanceof LambdaExpressionTree) {
-                    LambdaExpressionTree lambdaExpressionTree =
-                        (LambdaExpressionTree) codePath.getLeaf();
+                  if (codePath.getLeaf() instanceof LambdaExpressionTree lambdaExpressionTree) {
                     MethodTree enclMethod =
                         ASTHelpers.findEnclosingNode(codePath, MethodTree.class);
                     ClassTree enclClass =
                         castToNonNull(ASTHelpers.findEnclosingNode(codePath, ClassTree.class));
                     ast = new UnderlyingAST.CFGLambda(lambdaExpressionTree, enclClass, enclMethod);
                     bodyPath = new TreePath(codePath, lambdaExpressionTree.getBody());
-                  } else if (codePath.getLeaf() instanceof MethodTree) {
-                    MethodTree method = (MethodTree) codePath.getLeaf();
+                  } else if (codePath.getLeaf() instanceof MethodTree method) {
                     ClassTree enclClass =
                         castToNonNull(ASTHelpers.findEnclosingNode(codePath, ClassTree.class));
                     ast = new UnderlyingAST.CFGMethod(method, enclClass);

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

@@ -293,13 +293,11 @@ public Type visitMethodType(Type.MethodType t, Type other) {
 
     @Override
     public Type visitClassType(Type.ClassType t, Type other) {
-      if (other instanceof Type.WildcardType wt) {
-        if (wt.kind == BoundKind.EXTENDS) {
-          // As a temporary measure, we restore nullability annotations from the upper bound of the
-          // wildcard.
-          // TODO revisit this decision when we add fuller support for inference and wildcards.
-          return visit(t, wt.getExtendsBound());
-        }
+      if (other instanceof Type.WildcardType wt && wt.kind == BoundKind.EXTENDS) {
+        // As a temporary measure, we restore nullability annotations from the upper bound of the
+        // wildcard.
+        // TODO revisit this decision when we add fuller support for inference and wildcards.
+        return visit(t, wt.getExtendsBound());
       }
 
       Type updated = updateDirectNullabilityAnnotationsForType(t, other);

nullaway/src/main/java/com/uber/nullaway/handlers/AbstractFieldContractHandler.java

@@ -184,11 +184,10 @@ protected boolean validateAnnotationSyntax(
           return false;
         }
         VariableElement field = getFieldOfClass(classSymbol, fieldName);
-        if (field != null) {
-          if (field.getModifiers().contains(Modifier.STATIC)) {
-            continue;
-          }
+        if (field != null && field.getModifiers().contains(Modifier.STATIC)) {
+          continue;
         }
+
         if (fieldName.contains(".")) {
           if (!fieldName.startsWith(THIS_NOTATION)) {
             message =
@@ -264,13 +263,12 @@ protected boolean validateAnnotationSyntax(
   }
 
   protected boolean isThisDotStaticField(Symbol.ClassSymbol classSymbol, String expression) {
-    if (expression.contains(".")) {
-      if (expression.startsWith(THIS_NOTATION)) {
-        String fieldName = expression.substring(THIS_NOTATION.length());
-        VariableElement field = getFieldOfClass(classSymbol, fieldName);
-        return field != null && field.getModifiers().contains(Modifier.STATIC);
-      }
+    if (expression.contains(".") && expression.startsWith(THIS_NOTATION)) {
+      String fieldName = expression.substring(THIS_NOTATION.length());
+      VariableElement field = getFieldOfClass(classSymbol, fieldName);
+      return field != null && field.getModifiers().contains(Modifier.STATIC);
     }
+
     return false;
   }
 }

nullaway/src/main/java/com/uber/nullaway/handlers/contract/ContractCheckHandler.java

@@ -255,13 +255,12 @@ private static String getErrorMessageForViolatedContract(
   private static void collectNestedReturnedExpressions(
       TreePath expressionPath, List<TreePath> output) {
     ExpressionTree expression = (ExpressionTree) expressionPath.getLeaf();
-    while (expression instanceof ParenthesizedTree) {
-      ExpressionTree nestedExpression = ((ParenthesizedTree) expression).getExpression();
+    while (expression instanceof ParenthesizedTree parenthesizedTree) {
+      ExpressionTree nestedExpression = parenthesizedTree.getExpression();
       expressionPath = new TreePath(expressionPath, nestedExpression);
       expression = nestedExpression;
     }
-    if (expression instanceof ConditionalExpressionTree) {
-      ConditionalExpressionTree conditionalExpression = (ConditionalExpressionTree) expression;
+    if (expression instanceof ConditionalExpressionTree conditionalExpression) {
       TreePath truePath = new TreePath(expressionPath, conditionalExpression.getTrueExpression());
       TreePath falsePath = new TreePath(expressionPath, conditionalExpression.getFalseExpression());
       collectNestedReturnedExpressions(truePath, output);

nullaway/src/main/java/com/uber/nullaway/handlers/contract/fieldcontract/EnsuresNonNullHandler.java

@@ -94,7 +94,7 @@ protected boolean validateAnnotationSemantics(
             .stream()
             .map(e -> e.getSimpleName().toString())
             .collect(Collectors.toSet());
-    Set<String> nonnullFieldsAtExit = new HashSet<String>();
+    Set<String> nonnullFieldsAtExit = new HashSet<>();
     nonnullFieldsAtExit.addAll(nonnullFieldsOfReceiverAtExit);
     nonnullFieldsAtExit.addAll(nonnullStaticFieldsAtExit);
     Set<String> fieldNames = getAnnotationValueArray(methodSymbol, annotName, false);

nullaway/src/main/java/com/uber/nullaway/handlers/contract/fieldcontract/EnsuresNonNullIfHandler.java

@@ -195,8 +195,7 @@ public void onDataflowVisitReturn(
     // Whether the return true expression evaluates to a boolean literal or not.  If null, then not
     // a boolean literal.
     Boolean expressionAsBoolean = null;
-    if (returnTree.getExpression() instanceof LiteralTree) {
-      LiteralTree expressionAsLiteral = (LiteralTree) returnTree.getExpression();
+    if (returnTree.getExpression() instanceof LiteralTree expressionAsLiteral) {
       if (expressionAsLiteral.getValue() instanceof Boolean) {
         expressionAsBoolean = (Boolean) expressionAsLiteral.getValue();
       }