Replace Xlint deprecation check with custom errorprone check

api/incubator/src/main/java/io/opentelemetry/api/incubator/common/ArrayBackedExtendedAttributes.java

@@ -119,7 +119,7 @@ private Value<?> getAsValue(String keyName) {
     return null;
   }
 
-  @SuppressWarnings("unchecked")
+  @SuppressWarnings({"unchecked", "deprecation"}) // deprecation: EXTENDED_ATTRIBUTES
   @Nullable
   private static Value<?> asValue(ExtendedAttributeType type, Object value) {
     switch (type) {

api/incubator/src/main/java/io/opentelemetry/api/incubator/common/ArrayBackedExtendedAttributesBuilder.java

@@ -56,7 +56,7 @@ public <T> ExtendedAttributesBuilder put(ExtendedAttributeKey<T> key, T value) {
     return this;
   }
 
-  @SuppressWarnings("unchecked")
+  @SuppressWarnings({"unchecked", "deprecation"}) // deprecation: EXTENDED_ATTRIBUTES
   private void putValue(ExtendedAttributeKey<?> key, Value<?> valueObj) {
     // Convert VALUE type to narrower type when possible
     String keyName = key.getKey();

buildSrc/src/main/kotlin/otel.java-conventions.gradle.kts

@@ -91,6 +91,10 @@ tasks {
             "-Xlint:-options",
             "-Xlint:-serial",
             "-Xlint:-this-escape",
+            // We suppress the "deprecation" warning because --release 8 causes javac to warn on
+            // importing deprecated classes (fixed in JDK 9+, see https://bugs.openjdk.org/browse/JDK-8032211).
+            // We use a custom Error Prone check instead (OtelDeprecatedApiUsage).
+            "-Xlint:-deprecation",
             // Fail build on any warning
             "-Werror",
           ),

custom-checks/src/main/java/io/opentelemetry/gradle/customchecks/OtelDeprecatedApiUsage.java

@@ -0,0 +1,189 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.gradle.customchecks;
+
+import static com.google.errorprone.BugPattern.LinkType.NONE;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.IdentifierTree;
+import com.sun.source.tree.ImportTree;
+import com.sun.source.tree.MemberReferenceTree;
+import com.sun.source.tree.MemberSelectTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.NewClassTree;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Symbol;
+import javax.annotation.Nullable;
+
+/**
+ * Error Prone check that detects usage of deprecated APIs.
+ *
+ * <p>This is similar to javac's -Xlint:deprecation but properly honors {@code @SuppressWarnings}
+ * (including on import statements, which javac doesn't support with --release 8 due to <a
+ * href="https://bugs.openjdk.org/browse/JDK-8032211">JDK-8032211</a>).
+ *
+ * <p>Can be suppressed with {@code @SuppressWarnings("deprecation")}.
+ */
+@BugPattern(
+    summary = "Use of deprecated API",
+    severity = ERROR,
+    linkType = NONE,
+    altNames = "deprecation", // so it can be suppressed with @SuppressWarnings("deprecation")
+    suppressionAnnotations = SuppressWarnings.class)
+public class OtelDeprecatedApiUsage extends BugChecker
+    implements BugChecker.MethodInvocationTreeMatcher,
+        BugChecker.NewClassTreeMatcher,
+        BugChecker.MemberSelectTreeMatcher,
+        BugChecker.MemberReferenceTreeMatcher,
+        BugChecker.IdentifierTreeMatcher {
+
+  private static final long serialVersionUID = 1L;
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    Symbol sym = ASTHelpers.getSymbol(tree);
+    return checkDeprecated(sym, tree, state);
+  }
+
+  @Override
+  public Description matchNewClass(NewClassTree tree, VisitorState state) {
+    Symbol sym = ASTHelpers.getSymbol(tree);
+    return checkDeprecated(sym, tree, state);
+  }
+
+  @Override
+  public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
+    Symbol sym = ASTHelpers.getSymbol(tree);
+    return checkDeprecated(sym, tree, state);
+  }
+
+  @Override
+  public Description matchMemberReference(MemberReferenceTree tree, VisitorState state) {
+    Symbol sym = ASTHelpers.getSymbol(tree);
+    return checkDeprecated(sym, tree, state);
+  }
+
+  @Override
+  public Description matchIdentifier(IdentifierTree tree, VisitorState state) {
+    Symbol sym = ASTHelpers.getSymbol(tree);
+    return checkDeprecated(sym, tree, state);
+  }
+
+  private Description checkDeprecated(Symbol sym, Tree tree, VisitorState state) {
+    if (sym == null) {
+      return Description.NO_MATCH;
+    }
+
+    // Don't warn on import statements
+    if (isInsideImport(state)) {
+      return Description.NO_MATCH;
+    }
+
+    // Check if the symbol itself is deprecated
+    if (!isDeprecated(sym, state)) {
+      return Description.NO_MATCH;
+    }
+
+    // Don't warn if we're inside a deprecated context (class, method, etc.)
+    if (isInsideDeprecatedCode(state)) {
+      return Description.NO_MATCH;
+    }
+
+    // Don't warn if the deprecated symbol is in the same top-level class (matches javac behavior)
+    if (isInSameTopLevelClass(sym, state)) {
+      return Description.NO_MATCH;
+    }
+
+    return buildDescription(tree).setMessage("Use of deprecated API: " + sym).build();
+  }
+
+  private static boolean isInsideImport(VisitorState state) {
+    for (Tree tree : state.getPath()) {
+      if (tree instanceof ImportTree) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static boolean isDeprecated(Symbol sym, VisitorState state) {
+    // First try the symbol's isDeprecated() method
+    if (sym.isDeprecated()) {
+      return true;
+    }
+    // Also check for @Deprecated annotation (some symbols may not have flag set)
+    return ASTHelpers.hasAnnotation(sym, "java.lang.Deprecated", state);
+  }
+
+  private static boolean isInsideDeprecatedCode(VisitorState state) {
+    // Check enclosing elements (method, class) for @Deprecated
+    // Skip the first element which is the current node being checked
+    boolean first = true;
+    for (Tree tree : state.getPath()) {
+      if (first) {
+        first = false;
+        continue;
+      }
+      Symbol sym = ASTHelpers.getSymbol(tree);
+      if (sym != null && isDeprecated(sym, state)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static boolean isInSameTopLevelClass(Symbol sym, VisitorState state) {
+    // Get the top-level class containing the deprecated symbol
+    Symbol.ClassSymbol deprecatedTopLevel = getTopLevelClass(sym);
+    if (deprecatedTopLevel == null) {
+      return false;
+    }
+
+    // Get the top-level class containing the current usage by walking the tree path
+    // Skip the first element (the node being checked) to find the enclosing class
+    Symbol.ClassSymbol usageTopLevel = null;
+    boolean first = true;
+    for (Tree tree : state.getPath()) {
+      if (first) {
+        first = false;
+        continue;
+      }
+      Symbol treeSym = ASTHelpers.getSymbol(tree);
+      if (treeSym instanceof Symbol.ClassSymbol classSymbol) {
+        usageTopLevel = getTopLevelClass(classSymbol);
+        if (usageTopLevel != null) {
+          break;
+        }
+      }
+    }
+    if (usageTopLevel == null) {
+      return false;
+    }
+
+    return deprecatedTopLevel.equals(usageTopLevel);
+  }
+
+  @Nullable
+  private static Symbol.ClassSymbol getTopLevelClass(Symbol sym) {
+    Symbol current = sym;
+    while (current != null) {
+      if (current instanceof Symbol.ClassSymbol classSymbol) {
+        Symbol owner = classSymbol.owner;
+        // Top-level class is owned by a package
+        if (owner instanceof Symbol.PackageSymbol) {
+          return classSymbol;
+        }
+      }
+      current = current.owner;
+    }
+    return null;
+  }
+}

custom-checks/src/main/java/io/opentelemetry/gradle/customchecks/OtelInternalJavadoc.java

@@ -5,6 +5,7 @@
 
 package io.opentelemetry.gradle.customchecks;
 
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 
 import com.google.errorprone.BugPattern;
@@ -26,7 +27,8 @@
             + "\", or \""
             + OtelInternalJavadoc.EXPECTED_INTERNAL_COMMENT_V2
             + "\"",
-    severity = WARNING)
+    severity = WARNING,
+    linkType = NONE)
 public class OtelInternalJavadoc extends BugChecker implements BugChecker.ClassTreeMatcher {
 
   private static final long serialVersionUID = 1L;

custom-checks/src/main/java/io/opentelemetry/gradle/customchecks/OtelPrivateConstructorForUtilityClass.java

@@ -5,6 +5,7 @@
 
 package io.opentelemetry.gradle.customchecks;
 
+import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.matchers.Description.NO_MATCH;
 
@@ -18,7 +19,8 @@
 @BugPattern(
     summary =
         "Classes which are not intended to be instantiated should be made non-instantiable with a private constructor. This includes utility classes (classes with only static members), and the main class.",
-    severity = WARNING)
+    severity = WARNING,
+    linkType = NONE)
 public class OtelPrivateConstructorForUtilityClass extends BugChecker
     implements BugChecker.ClassTreeMatcher {
 

custom-checks/src/main/resources/META-INF/services/com.google.errorprone.bugpatterns.BugChecker

@@ -1,2 +1,3 @@
+io.opentelemetry.gradle.customchecks.OtelDeprecatedApiUsage
 io.opentelemetry.gradle.customchecks.OtelInternalJavadoc
 io.opentelemetry.gradle.customchecks.OtelPrivateConstructorForUtilityClass