Various cleanups suggested by IntelliJ (#1423)

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

## Summary by CodeRabbit

## Release Notes

* **Refactor**
* Code modernization: Updated internal implementation to use modern Java
language features and improved patterns for better code clarity and
maintainability.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: msridhar

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

@@ -316,7 +316,7 @@ public NullAway(ErrorProneFlags flags) {
     genericsChecks = new GenericsChecks(this, config, handler);
   }
 
-  public boolean isMethodUnannotated(MethodInvocationNode invocationNode) {
+  public boolean isMethodUnannotated(@Nullable MethodInvocationNode invocationNode) {
     return invocationNode == null
         || codeAnnotationInfo.isSymbolUnannotated(
             ASTHelpers.getSymbol(invocationNode.getTree()), config, handler);
@@ -518,9 +518,8 @@ public Description matchAssignment(AssignmentTree tree, VisitorState state) {
       genericsChecks.checkTypeParameterNullnessForAssignability(tree, state);
     }
 
-    if (config.isJSpecifyMode() && tree.getVariable() instanceof ArrayAccessTree) {
+    if (config.isJSpecifyMode() && tree.getVariable() instanceof ArrayAccessTree arrayAccess) {
       // check for a write of a @Nullable value into @NonNull array contents
-      ArrayAccessTree arrayAccess = (ArrayAccessTree) tree.getVariable();
       ExpressionTree arrayExpr = arrayAccess.getExpression();
       ExpressionTree expression = tree.getExpression();
       Symbol arraySymbol = ASTHelpers.getSymbol(arrayExpr);
@@ -856,7 +855,7 @@ private Description checkParamOverriding(
               + "functional interface method "
               + ASTHelpers.enclosingClass(overriddenMethod)
               + "."
-              + overriddenMethod.toString()
+              + overriddenMethod
               + " is @Nullable";
       return errorBuilder.createErrorDescription(
           new ErrorMessage(MessageTypes.WRONG_OVERRIDE_PARAM, message),
@@ -898,7 +897,7 @@ private Description checkParamOverriding(
                 + "method "
                 + ASTHelpers.enclosingClass(overriddenMethod)
                 + "."
-                + overriddenMethod.toString()
+                + overriddenMethod
                 + " is @Nullable";
         Tree errorTree;
         if (memberReferenceTree != null) {
@@ -1109,14 +1108,14 @@ && getMethodReturnNullness(overridingMethod, state, Nullness.NONNULL)
             "referenced method returns @Nullable, but functional interface method "
                 + ASTHelpers.enclosingClass(overriddenMethod)
                 + "."
-                + overriddenMethod.toString()
+                + overriddenMethod
                 + " returns @NonNull";
       } else {
         message =
             "method returns @Nullable, but superclass method "
                 + ASTHelpers.enclosingClass(overriddenMethod)
                 + "."
-                + overriddenMethod.toString()
+                + overriddenMethod
                 + " returns @NonNull";
       }
 
@@ -1375,7 +1374,7 @@ private ImmutableSet<Element> safeInitByCalleeBefore(
         if (curStmt instanceof TryTree tryTree) {
           // ToDo: Should we check initialization inside tryTree.getResources ? What is the scope of
           // that initialization?
-          if (tryTree.getCatches().size() == 0) {
+          if (tryTree.getCatches().isEmpty()) {
             if (tryTree.getBlock() != null) {
               resultBuilder.addAll(
                   safeInitByCalleeBefore(
@@ -1458,7 +1457,7 @@ private ImmutableMultimap<Tree, Element> computeTree2Init(
       }
     }
     // all the initializer blocks have run before any code inside a constructor
-    constructors.stream().forEach((c) -> builder.putAll(c, initThusFar));
+    constructors.forEach((c) -> builder.putAll(c, initThusFar));
     Symbol.ClassSymbol classSymbol = ASTHelpers.getSymbol(enclosingClass);
     FieldInitEntities entities = castToNonNull(class2Entities.get(classSymbol));
     if (entities.instanceInitializerMethods().size() == 1) {
@@ -1506,7 +1505,7 @@ private boolean okToReadBeforeInitialized(TreePath path, VisitorState state) {
       // ok if it's invoking castToNonNull and the read is the argument
       Symbol.MethodSymbol methodSymbol = ASTHelpers.getSymbol(methodInvoke);
       String qualifiedName =
-          ASTHelpers.enclosingClass(methodSymbol) + "." + methodSymbol.getSimpleName().toString();
+          ASTHelpers.enclosingClass(methodSymbol) + "." + methodSymbol.getSimpleName();
       List<? extends ExpressionTree> arguments = methodInvoke.getArguments();
       Integer castToNonNullArg;
       if (qualifiedName.equals(config.getCastToNonNullMethod())
@@ -1517,10 +1516,7 @@ private boolean okToReadBeforeInitialized(TreePath path, VisitorState state) {
             handler.castToNonNullArgumentPositionsForMethod(
                 arguments, null, new MethodAnalysisContext(this, state, methodSymbol));
       }
-      if (castToNonNullArg != null && leaf.equals(arguments.get(castToNonNullArg))) {
-        return true;
-      }
-      return false;
+      return castToNonNullArg != null && leaf.equals(arguments.get(castToNonNullArg));
     }
     return false;
   }
@@ -2034,7 +2030,7 @@ private Description checkCastToNonNullTakesNullable(
       Symbol.MethodSymbol methodSymbol,
       List<? extends ExpressionTree> actualParams) {
     String qualifiedName =
-        ASTHelpers.enclosingClass(methodSymbol) + "." + methodSymbol.getSimpleName().toString();
+        ASTHelpers.enclosingClass(methodSymbol) + "." + methodSymbol.getSimpleName();
     Integer castToNonNullPosition;
     if (qualifiedName.equals(config.getCastToNonNullMethod())
         && methodSymbol.getParameters().size() == 1) {
@@ -2055,8 +2051,7 @@ private Description checkCastToNonNullTakesNullable(
         throw new RuntimeException("no enclosing method, lambda or initializer!");
       } else if (enclosingMethodOrLambda.getLeaf() instanceof LambdaExpressionTree) {
         isInitializer = false;
-      } else if (enclosingMethodOrLambda.getLeaf() instanceof MethodTree) {
-        MethodTree enclosingMethod = (MethodTree) enclosingMethodOrLambda.getLeaf();
+      } else if (enclosingMethodOrLambda.getLeaf() instanceof MethodTree enclosingMethod) {
         isInitializer = isInitializerMethod(state, ASTHelpers.getSymbol(enclosingMethod));
       } else {
         // Initializer block
@@ -2239,7 +2234,7 @@ private SetMultimap<MethodTree, Symbol> checkConstructorInitialization(
       if (constructorInvokesAnother(constructor, state)) {
         continue;
       }
-      if (constructor.getParameters().size() == 0
+      if (constructor.getParameters().isEmpty()
           && (isExternalInitClass
               || symbolHasExternalInitAnnotation(ASTHelpers.getSymbol(constructor)))) {
         // external framework initializes fields in this case
@@ -2281,18 +2276,16 @@ private ImmutableSet<Element> guaranteedNonNullForConstructor(
   private boolean constructorInvokesAnother(MethodTree constructor, VisitorState state) {
     BlockTree body = constructor.getBody();
     List<? extends StatementTree> statements = body.getStatements();
-    if (statements.size() > 0) {
+    if (!statements.isEmpty()) {
       StatementTree statementTree = statements.get(0);
-      if (isThisCall(statementTree, state)) {
-        return true;
-      }
+      return isThisCall(statementTree, state);
     }
     return false;
   }
 
   private Set<Symbol> notInitializedStatic(FieldInitEntities entities, VisitorState state) {
     ImmutableSet<Symbol> nonNullStaticFields = entities.nonnullStaticFields();
-    Set<Element> initializedInStaticInitializers = new LinkedHashSet<Element>();
+    Set<Element> initializedInStaticInitializers = new LinkedHashSet<>();
     AccessPathNullnessAnalysis nullnessAnalysis = getNullnessAnalysis(state);
     for (BlockTree initializer : entities.staticInitializerBlocks()) {
       Set<Element> nonnullAtExit =
@@ -2306,7 +2299,7 @@ private Set<Symbol> notInitializedStatic(FieldInitEntities entities, VisitorStat
               new TreePath(state.getPath(), initializerMethod), state.context);
       initializedInStaticInitializers.addAll(nonnullAtExit);
     }
-    Set<Symbol> notInitializedStaticFields = new LinkedHashSet<Symbol>();
+    Set<Symbol> notInitializedStaticFields = new LinkedHashSet<>();
     for (Symbol field : nonNullStaticFields) {
       if (!initializedInStaticInitializers.contains(field)) {
         notInitializedStaticFields.add(field);
@@ -2349,7 +2342,7 @@ private Set<Element> getSafeInitMethods(
       // there is also an
       // exception of the full method.
       if (stmt instanceof TryTree tryTree) {
-        if (tryTree.getCatches().size() == 0) {
+        if (tryTree.getCatches().isEmpty()) {
           if (tryTree.getBlock() != null) {
             result.addAll(getSafeInitMethods(tryTree.getBlock(), classSymbol, state));
           }
@@ -2683,12 +2676,10 @@ private boolean mayBeNullMethodCall(
           "%s not found as a descendant of %s",
           invocationTree,
           path.getLeaf());
-      if (genericsChecks
+      return genericsChecks
           .getGenericReturnNullnessAtInvocation(
               exprSymbol, invocationTree, invocationPath, state, false)
-          .equals(Nullness.NULLABLE)) {
-        return true;
-      }
+          .equals(Nullness.NULLABLE);
     }
     return false;
   }

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

@@ -271,7 +271,7 @@ private void reportInvalidTypeArgumentError(
             ErrorMessage.MessageTypes.TYPE_PARAMETER_CANNOT_BE_NULLABLE,
             String.format(
                 "Type argument cannot be @Nullable, as method %s's type variable %s is not @Nullable",
-                methodSymbol.toString(), typeVariable.tsym.toString()));
+                methodSymbol, typeVariable.tsym.toString()));
     state.reportMatch(
         errorBuilder.createErrorDescription(
             errorMessage, analysis.buildDescription(tree), state, null));
@@ -420,9 +420,7 @@ private void reportInvalidOverridingMethodParamTypeError(
   private @Nullable Type getTreeType(Tree tree, VisitorState state) {
     tree = ASTHelpers.stripParentheses(tree);
     if (tree instanceof NewClassTree
-        && ((NewClassTree) tree).getIdentifier() instanceof ParameterizedTypeTree) {
-      ParameterizedTypeTree paramTypedTree =
-          (ParameterizedTypeTree) ((NewClassTree) tree).getIdentifier();
+        && ((NewClassTree) tree).getIdentifier() instanceof ParameterizedTypeTree paramTypedTree) {
       if (paramTypedTree.getTypeArguments().isEmpty()) {
         // diamond operator, which we do not yet support; for now, return null
         // TODO: support diamond operators
@@ -438,9 +436,8 @@ private void reportInvalidOverridingMethodParamTypeError(
         // type on the tree itself can be missing nested annotations for arrays; get the type from
         // the symbol for the variable instead
         result = castToNonNull(ASTHelpers.getSymbol(tree)).type;
-      } else if (tree instanceof IdentifierTree) {
+      } else if (tree instanceof IdentifierTree identifierTree) {
         // handle "this" specially, for cases where it appears inside an anonymous class
-        IdentifierTree identifierTree = (IdentifierTree) tree;
         Symbol symbol = castToNonNull(ASTHelpers.getSymbol(identifierTree));
         if (identifierTree.getName().contentEquals("this")) {
           Symbol owner = symbol.owner;
@@ -469,10 +466,9 @@ private void reportInvalidOverridingMethodParamTypeError(
         if (result != null && !(result instanceof Type.TypeVar)) {
           result = symbol.type;
         }
-      } else if (tree instanceof AssignmentTree) {
+      } else if (tree instanceof AssignmentTree assignmentTree) {
         // type on the tree itself can be missing nested annotations for arrays; get the type from
         // the symbol for the assigned location instead, if available
-        AssignmentTree assignmentTree = (AssignmentTree) tree;
         Symbol lhsSymbol = ASTHelpers.getSymbol(assignmentTree.getVariable());
         if (lhsSymbol != null) {
           result = lhsSymbol.type;
@@ -492,8 +488,7 @@ private void reportInvalidOverridingMethodParamTypeError(
             result =
                 TypeSubstitutionUtils.restoreExplicitNullabilityAnnotations(
                     returnType, result, config, Collections.emptyMap());
-          } else if (tree instanceof MemberSelectTree) {
-            MemberSelectTree memberSelectTree = (MemberSelectTree) tree;
+          } else if (tree instanceof MemberSelectTree memberSelectTree) {
             Symbol memberSelectSymbol = ASTHelpers.getSymbol(memberSelectTree);
             if (memberSelectSymbol != null && memberSelectSymbol.getKind().isField()) {
               Type fieldType = memberSelectSymbol.type;
@@ -827,7 +822,7 @@ private void generateConstraintsForPseudoAssignment(
       allInvocations.add(invTree);
       generateConstraintsForCall(
           state, path, lhsType, false, solver, symbol, invTree, allInvocations);
-    } else if (!(rhsExpr instanceof LambdaExpressionTree)) {
+    } else if (!(rhsExpr instanceof LambdaExpressionTree lambda)) {
       Type argumentType = getTreeType(rhsExpr, state);
       if (argumentType == null) {
         // bail out of any checking involving raw types for now
@@ -836,7 +831,6 @@ private void generateConstraintsForPseudoAssignment(
       argumentType = refineArgumentTypeWithDataflow(argumentType, rhsExpr, state, path);
       solver.addSubtypeConstraint(argumentType, lhsType, false);
     } else {
-      LambdaExpressionTree lambda = (LambdaExpressionTree) rhsExpr;
       handleLambdaInGenericMethodInference(state, path, solver, allInvocations, lhsType, lambda);
     }
   }
@@ -1632,17 +1626,15 @@ private InvocationAndContext getInvocationAndContextForInference(
           NullabilityUtil.findEnclosingMethodOrLambdaOrInitializer(parentPath);
       // TODO handle lambdas; https://github.com/uber/NullAway/issues/1288
       if (enclosingMethodOrLambda != null
-          && enclosingMethodOrLambda.getLeaf() instanceof MethodTree) {
-        MethodTree enclosingMethod = (MethodTree) enclosingMethodOrLambda.getLeaf();
+          && enclosingMethodOrLambda.getLeaf() instanceof MethodTree enclosingMethod) {
         Symbol.MethodSymbol methodSymbol = ASTHelpers.getSymbol(enclosingMethod);
         if (methodSymbol != null) {
           return new InvocationAndContext(invocation, methodSymbol.getReturnType(), false);
         }
       }
-    } else if (parent instanceof ExpressionTree) {
+    } else if (parent instanceof ExpressionTree exprParent) {
       // could be a parameter to another method call, or part of a conditional expression, etc.
       // in any case, just return the type of the parent expression
-      ExpressionTree exprParent = (ExpressionTree) parent;
       if (exprParent instanceof MethodInvocationTree parentInvocation) {
         if (isGenericCallNeedingInference(parentInvocation)) {
           // this is the case of a nested generic call, e.g., id(id(x)) where id is generic
@@ -1907,7 +1899,7 @@ private void checkTypeParameterNullnessForOverridingMethodParameterType(
     for (int i = 0; i < methodParameters.size(); i++) {
       Type overridingMethodParameterType = getTreeType(methodParameters.get(i), state);
       Type overriddenMethodParameterType = overriddenMethodParameterTypes.get(i);
-      if (overriddenMethodParameterType != null && overridingMethodParameterType != null) {
+      if (overridingMethodParameterType != null) {
         // allow contravariant subtyping
         if (!subtypeParameterNullability(
             overridingMethodParameterType, overriddenMethodParameterType, state)) {