Optimize methods that check for annotations on a Symbol (#1362)

These methods are called very frequently. Previously these methods
operated on `Stream`s, but that was causing overhead visible in
profiles. Switch them to use `Iterator`s and a callback `Predicate`.

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

## Summary by CodeRabbit

* **Refactor**
* Consolidated annotation-checking logic by introducing a centralized
utility method to streamline multiple annotation-matching operations
into a single, reusable component.
* Replaced stream-based checks with explicit iteration for improved
performance and code consistency across annotation-checking operations.

<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/NullabilityUtil.java

@@ -53,6 +53,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiPredicate;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.lang.model.element.AnnotationMirror;
@@ -191,6 +192,37 @@ public static Stream<? extends AnnotationMirror> getAllAnnotations(Symbol symbol
     return Stream.concat(symbol.getAnnotationMirrors().stream(), typeUseAnnotations);
   }
 
+  /**
+   * Check if any direct annotation a symbol matches a given predicate. Works for both source and
+   * bytecode.
+   *
+   * @param symbol the symbol
+   * @param config NullAway configuration
+   * @param predicate the predicate to match annotation names against
+   * @return true if any annotation on the symbol matches the predicate, false otherwise
+   */
+  public static boolean hasAnyAnnotationMatching(
+      Symbol symbol, Config config, Predicate<String> predicate) {
+    for (AnnotationMirror annotationMirror : symbol.getAnnotationMirrors()) {
+      if (predicate.test(annotationMirror.getAnnotationType().toString())) {
+        return true;
+      }
+    }
+    // to handle bytecodes, also check direct type-use annotations stored in attributes
+    Symbol typeAnnotationOwner =
+        symbol.getKind().equals(ElementKind.PARAMETER) ? symbol.owner : symbol;
+    for (Attribute.TypeCompound typeCompound : typeAnnotationOwner.getRawTypeAttributes()) {
+      if (!targetTypeMatches(symbol, typeCompound.position)
+          || !isDirectTypeUseAnnotation(typeCompound, symbol, config)) {
+        continue;
+      }
+      if (predicate.test(typeCompound.getAnnotationType().toString())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Retrieve the {@code value} attribute of a method annotation of some type.
    *

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

@@ -68,15 +68,10 @@ public static boolean isMonotonicNonNullAnnotation(String annotName) {
    * {@code symbol}. Used to reason whether a field may be null.
    */
   public static boolean hasNullableOrMonotonicNonNullAnnotation(Symbol symbol, Config config) {
-    return hasNullableOrMonotonicNonNullAnnotation(
-        NullabilityUtil.getAllAnnotations(symbol, config), config);
-  }
-
-  private static boolean hasNullableOrMonotonicNonNullAnnotation(
-      Stream<? extends AnnotationMirror> annotations, Config config) {
-    return annotations
-        .map(anno -> anno.getAnnotationType().toString())
-        .anyMatch(anno -> isNullableAnnotation(anno, config) || isMonotonicNonNullAnnotation(anno));
+    return NullabilityUtil.hasAnyAnnotationMatching(
+        symbol,
+        config,
+        annot -> isNullableAnnotation(annot, config) || isMonotonicNonNullAnnotation(annot));
   }
 
   // The following leastUpperBound and greatestLowerBound methods were created by handwriting a
@@ -219,7 +214,8 @@ public static boolean isNonNullAnnotation(String annotName, Config config) {
    * Config)}
    */
   public static boolean hasNonNullAnnotation(Symbol symbol, Config config) {
-    return hasNonNullAnnotation(NullabilityUtil.getAllAnnotations(symbol, config), config);
+    return NullabilityUtil.hasAnyAnnotationMatching(
+        symbol, config, annot -> isNonNullAnnotation(annot, config));
   }
 
   /**
@@ -230,7 +226,8 @@ public static boolean hasNonNullAnnotation(Symbol symbol, Config config) {
    * Config)}
    */
   public static boolean hasNullableAnnotation(Symbol symbol, Config config) {
-    return hasNullableAnnotation(NullabilityUtil.getAllAnnotations(symbol, config), config);
+    return NullabilityUtil.hasAnyAnnotationMatching(
+        symbol, config, annot -> isNullableAnnotation(annot, config));
   }
 
   private static boolean hasNullableTypeUseAnnotation(Symbol symbol, Config config) {
@@ -316,11 +313,21 @@ public static boolean varargsArrayIsNullable(Symbol paramSymbol, Config config)
 
   /** Checks if the symbol has a {@code @Nullable} declaration annotation */
   public static boolean hasNullableDeclarationAnnotation(Symbol symbol, Config config) {
-    return hasNullableAnnotation(symbol.getRawAttributes().stream(), config);
+    for (AnnotationMirror annotationMirror : symbol.getRawAttributes()) {
+      if (isNullableAnnotation(annotationMirror.getAnnotationType().toString(), config)) {
+        return true;
+      }
+    }
+    return false;
   }
 
   /** Checks if the symbol has a {@code @NonNull} declaration annotation */
   public static boolean hasNonNullDeclarationAnnotation(Symbol symbol, Config config) {
-    return hasNonNullAnnotation(symbol.getRawAttributes().stream(), config);
+    for (AnnotationMirror annotationMirror : symbol.getRawAttributes()) {
+      if (isNonNullAnnotation(annotationMirror.getAnnotationType().toString(), config)) {
+        return true;
+      }
+    }
+    return false;
   }
 }