8354556: Expand value-based class warnings to java.lang.ref API

make/langtools/src/classes/build/tools/symbolgenerator/CreateSymbols.java

@@ -304,13 +304,18 @@ public void createSymbols(String ctDescriptionFileExtra, String ctDescriptionFil
             "Ljdk/internal/ValueBased;";
     private static final String VALUE_BASED_ANNOTATION_INTERNAL =
             "Ljdk/internal/ValueBased+Annotation;";
+    private static final String REQUIRES_IDENTITY_ANNOTATION =
+            "Ljdk/internal/RequiresIdentity;";
+    private static final String REQUIRES_IDENTITY_ANNOTATION_INTERNAL =
+            "Ljdk/internal/RequiresIdentity+Annotation;";
     public static final Set<String> HARDCODED_ANNOTATIONS = new HashSet<>(
             List.of("Ljdk/Profile+Annotation;",
                     "Lsun/Proprietary+Annotation;",
                     PREVIEW_FEATURE_ANNOTATION_OLD,
                     PREVIEW_FEATURE_ANNOTATION_NEW,
                     VALUE_BASED_ANNOTATION,
-                    RESTRICTED_ANNOTATION));
+                    RESTRICTED_ANNOTATION,
+                    REQUIRES_IDENTITY_ANNOTATION));
 
     private void stripNonExistentAnnotations(LoadDescriptions data) {
         Set<String> allClasses = data.classes.name2Class.keySet();
@@ -1021,6 +1026,12 @@ private Annotation createAnnotation(AnnotationDescription desc) {
             annotationType = VALUE_BASED_ANNOTATION_INTERNAL;
         }
 
+        if (REQUIRES_IDENTITY_ANNOTATION.equals(annotationType)) {
+            //the non-public RequiresIdentity annotation will not be available in ct.sym,
+            //replace with purely synthetic javac-internal annotation:
+            annotationType = REQUIRES_IDENTITY_ANNOTATION_INTERNAL;
+        }
+
         if (RESTRICTED_ANNOTATION.equals(annotationType)) {
             //the non-public Restricted annotation will not be available in ct.sym,
             //replace with purely synthetic javac-internal annotation:
@@ -2202,6 +2213,7 @@ private boolean readAttribute(FeatureDescription feature, Attribute<?> attr) {
                 chd.permittedSubclasses = a.permittedSubclasses().stream().map(ClassEntry::asInternalName).collect(Collectors.toList());
             }
             case ModuleMainClassAttribute a -> ((ModuleHeaderDescription) feature).moduleMainClass = a.mainClass().asInternalName();
+            case RuntimeVisibleTypeAnnotationsAttribute a -> {/* do nothing for now */}
             default -> throw new IllegalArgumentException("Unhandled attribute: " + attr.attributeName()); // Do nothing
         }
 

src/java.base/share/classes/java/lang/ref/Cleaner.java

@@ -219,7 +219,7 @@ public static Cleaner create(ThreadFactory threadFactory) {
      * @param action a {@code Runnable} to invoke when the object becomes phantom reachable
      * @return a {@code Cleanable} instance
      */
-    public Cleanable register(Object obj, Runnable action) {
+    public Cleanable register(@jdk.internal.RequiresIdentity Object obj, Runnable action) {
         Objects.requireNonNull(obj, "obj");
         Objects.requireNonNull(action, "action");
         return new CleanerImpl.PhantomCleanableRef(obj, this, action);

src/java.base/share/classes/java/lang/ref/PhantomReference.java

@@ -51,7 +51,7 @@
  * @since    1.2
  */
 
-public non-sealed class PhantomReference<T> extends Reference<T> {
+public non-sealed class PhantomReference<@jdk.internal.RequiresIdentity T> extends Reference<T> {
 
     /**
      * Returns this reference object's referent.  Because the referent of a
@@ -101,7 +101,7 @@ void clearImpl() {
      * @param q the queue with which the reference is to be registered,
      *          or {@code null} if registration is not required
      */
-    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
+    public PhantomReference(@jdk.internal.RequiresIdentity T referent, ReferenceQueue<? super T> q) {
         super(referent, q);
     }
 

src/java.base/share/classes/java/lang/ref/Reference.java

@@ -44,7 +44,7 @@
  * @sealedGraph
  */
 
-public abstract sealed class Reference<T>
+public abstract sealed class Reference<@jdk.internal.RequiresIdentity T>
     permits PhantomReference, SoftReference, WeakReference, FinalReference {
 
     /* The state of a Reference object is characterized by two attributes.  It

src/java.base/share/classes/java/lang/ref/ReferenceQueue.java

@@ -46,7 +46,7 @@
  * @since    1.2
  */
 
-public class ReferenceQueue<T> {
+public class ReferenceQueue<@jdk.internal.RequiresIdentity T> {
     private static class Null extends ReferenceQueue<Object> {
         @Override
         boolean enqueue(Reference<?> r) {

src/java.base/share/classes/java/lang/ref/SoftReference.java

@@ -62,7 +62,7 @@
  * @since    1.2
  */
 
-public non-sealed class SoftReference<T> extends Reference<T> {
+public non-sealed class SoftReference<@jdk.internal.RequiresIdentity T> extends Reference<T> {
 
     /**
      * Timestamp clock, updated by the garbage collector
@@ -82,7 +82,7 @@ public non-sealed class SoftReference<T> extends Reference<T> {
      *
      * @param referent object the new soft reference will refer to
      */
-    public SoftReference(T referent) {
+    public SoftReference(@jdk.internal.RequiresIdentity T referent) {
         super(referent);
         this.timestamp = clock;
     }
@@ -96,7 +96,7 @@ public SoftReference(T referent) {
      *          or {@code null} if registration is not required
      *
      */
-    public SoftReference(T referent, ReferenceQueue<? super T> q) {
+    public SoftReference(@jdk.internal.RequiresIdentity T referent, ReferenceQueue<? super T> q) {
         super(referent, q);
         this.timestamp = clock;
     }

src/java.base/share/classes/java/lang/ref/WeakReference.java

@@ -46,15 +46,15 @@
  * @since    1.2
  */
 
-public non-sealed class WeakReference<T> extends Reference<T> {
+public non-sealed class WeakReference<@jdk.internal.RequiresIdentity T> extends Reference<T> {
 
     /**
      * Creates a new weak reference that refers to the given object.  The new
      * reference is not registered with any queue.
      *
      * @param referent object the new weak reference will refer to
      */
-    public WeakReference(T referent) {
+    public WeakReference(@jdk.internal.RequiresIdentity T referent) {
         super(referent);
     }
 
@@ -66,7 +66,7 @@ public WeakReference(T referent) {
      * @param q the queue with which the reference is to be registered,
      *          or {@code null} if registration is not required
      */
-    public WeakReference(T referent, ReferenceQueue<? super T> q) {
+    public WeakReference(@jdk.internal.RequiresIdentity T referent, ReferenceQueue<? super T> q) {
         super(referent, q);
     }
 

src/java.base/share/classes/java/util/WeakHashMap.java

@@ -132,7 +132,7 @@
  * @see         java.util.HashMap
  * @see         java.lang.ref.WeakReference
  */
-public class WeakHashMap<K,V>
+public class WeakHashMap<@jdk.internal.RequiresIdentity K,V>
     extends AbstractMap<K,V>
     implements Map<K,V> {
 
@@ -457,7 +457,7 @@ Entry<K,V> getEntry(Object key) {
      *         (A {@code null} return can also indicate that the map
      *         previously associated {@code null} with {@code key}.)
      */
-    public V put(K key, V value) {
+    public V put(@jdk.internal.RequiresIdentity K key, V value) {
         Object k = maskNull(key);
         int h = hash(k);
         Entry<K,V>[] tab = getTable();

src/java.base/share/classes/jdk/internal/RequiresIdentity.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.internal;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE_PARAMETER;
+
+/**
+ * Indicates that the annotated parameter or type parameter is not expected to be a
+ * Value Based class.
+ * Using a parameter or type parameter of a <a href="../lang/doc-files/ValueBased.html">value-based classes</a>
+ * should produce warnings about behavior that is inconsistent with identity based semantics.
+ *
+ * Note this internal annotation is handled specially by the javac compiler.
+ * To work properly with {@code --release older-release}, it requires special
+ * handling in {@code make/langtools/src/classes/build/tools/symbolgenerator/CreateSymbols.java}
+ * and {@code src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java}.
+ *
+ * @since 25
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value={PARAMETER, TYPE_PARAMETER})
+public @interface RequiresIdentity {
+}

src/java.base/share/classes/jdk/internal/ValueBased.java

@@ -46,4 +46,3 @@
 @Target(value={TYPE})
 public @interface ValueBased {
 }
-

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Lint.java

@@ -25,11 +25,15 @@
 
 package com.sun.tools.javac.code;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.EnumSet;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.Set;
 import java.util.stream.Stream;
 
 import com.sun.tools.javac.main.Option;
@@ -119,7 +123,7 @@ public Lint suppress(LintCategory... lc) {
     private EnumSet<LintCategory> values;
     private EnumSet<LintCategory> suppressedValues;
 
-    private static final Map<String, LintCategory> map = new ConcurrentHashMap<>(20);
+    private static final Map<String, LintCategory> map = new LinkedHashMap<>(40);
 
     @SuppressWarnings("this-escape")
     protected Lint(Context context) {
@@ -149,10 +153,10 @@ private void initializeRootIfNeeded() {
             return;
 
         // Initialize enabled categories based on "-Xlint" flags
-        if (options.isSet(Option.XLINT) || options.isSet(Option.XLINT_CUSTOM, "all")) {
+        if (options.isSet(Option.XLINT) || options.isSet(Option.XLINT_CUSTOM, Option.LINT_CUSTOM_ALL)) {
             // If -Xlint or -Xlint:all is given, enable all categories by default
             values = EnumSet.allOf(LintCategory.class);
-        } else if (options.isSet(Option.XLINT_CUSTOM, "none")) {
+        } else if (options.isSet(Option.XLINT_CUSTOM, Option.LINT_CUSTOM_NONE)) {
             // if -Xlint:none is given, disable all categories by default
             values = LintCategory.newEmptySet();
         } else {
@@ -173,15 +177,15 @@ private void initializeRootIfNeeded() {
             if (!options.isSet(Option.PREVIEW)) {
                 values.add(LintCategory.PREVIEW);
             }
-            values.add(LintCategory.SYNCHRONIZATION);
+            values.add(LintCategory.IDENTITY);
             values.add(LintCategory.INCUBATING);
         }
 
         // Look for specific overrides
         for (LintCategory lc : LintCategory.values()) {
-            if (options.isSet(Option.XLINT_CUSTOM, lc.option)) {
+            if (options.isExplicitlyEnabled(Option.XLINT, lc)) {
                 values.add(lc);
-            } else if (options.isSet(Option.XLINT_CUSTOM, "-" + lc.option)) {
+            } else if (options.isExplicitlyDisabled(Option.XLINT, lc)) {
                 values.remove(lc);
             }
         }
@@ -261,6 +265,11 @@ public enum LintCategory {
          */
         FINALLY("finally"),
 
+        /**
+         * Warn about uses of @ValueBased classes where an identity class is expected.
+         */
+        IDENTITY("identity", true, "synchronization"),
+
         /**
          * Warn about use of incubating modules.
          *
@@ -363,11 +372,6 @@ public enum LintCategory {
          */
         STRICTFP("strictfp"),
 
-        /**
-         * Warn about synchronization attempts on instances of @ValueBased classes.
-         */
-        SYNCHRONIZATION("synchronization"),
-
         /**
          * Warn about issues relating to use of text blocks
          *
@@ -410,10 +414,14 @@ public enum LintCategory {
             this(option, true);
         }
 
-        LintCategory(String option, boolean annotationSuppression) {
+        LintCategory(String option, boolean annotationSuppression, String... aliases) {
             this.option = option;
             this.annotationSuppression = annotationSuppression;
-            map.put(option, this);
+            ArrayList<String> optionList = new ArrayList<>(1 + aliases.length);
+            optionList.add(option);
+            Collections.addAll(optionList, aliases);
+            this.optionList = Collections.unmodifiableList(optionList);
+            this.optionList.forEach(ident -> map.put(ident, this));
         }
 
         /**
@@ -426,13 +434,23 @@ public static Optional<LintCategory> get(String option) {
             return Optional.ofNullable(map.get(option));
         }
 
+        /**
+         * Get all lint category option strings and aliases.
+         */
+        public static Set<String> options() {
+            return Collections.unmodifiableSet(map.keySet());
+        }
+
         public static EnumSet<LintCategory> newEmptySet() {
             return EnumSet.noneOf(LintCategory.class);
         }
 
-        /** Get the string representing this category in @SuppressAnnotations and -Xlint options. */
+        /** Get the "canonical" string representing this category in @SuppressAnnotations and -Xlint options. */
         public final String option;
 
+        /** Get a list containing "option" followed by zero or more aliases. */
+        public final List<String> optionList;
+
         /** Does this category support being suppressed by the {@code @SuppressWarnings} annotation? */
         public final boolean annotationSuppression;
     }
@@ -496,20 +514,6 @@ public EnumSet<LintCategory> suppressionsFrom(Symbol symbol) {
         return suppressions;
     }
 
-    /**
-     * Retrieve the recognized lint categories suppressed by the given @SuppressWarnings annotation.
-     *
-     * @param annotation @SuppressWarnings annotation, or null
-     * @return set of lint categories, possibly empty but never null
-     */
-    private EnumSet<LintCategory> suppressionsFrom(JCAnnotation annotation) {
-        initializeSymbolsIfNeeded();
-        if (annotation == null)
-            return LintCategory.newEmptySet();
-        Assert.check(annotation.attribute.type.tsym == syms.suppressWarningsType.tsym);
-        return suppressionsFrom(Stream.of(annotation).map(anno -> anno.attribute));
-    }
-
     // Find the @SuppressWarnings annotation in the given stream and extract the recognized suppressions
     private EnumSet<LintCategory> suppressionsFrom(Stream<Attribute.Compound> attributes) {
         initializeSymbolsIfNeeded();

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symtab.java

@@ -228,6 +228,8 @@ public static Symtab instance(Context context) {
     public final Type constantBootstrapsType;
     public final Type valueBasedType;
     public final Type valueBasedInternalType;
+    public final Type requiresIdentityType;
+    public final Type requiresIdentityInternalType;
     public final Type classDescType;
     public final Type enumDescType;
 
@@ -610,6 +612,8 @@ public <R, P> R accept(ElementVisitor<R, P> v, P p) {
         constantBootstrapsType = enterClass("java.lang.invoke.ConstantBootstraps");
         valueBasedType = enterClass("jdk.internal.ValueBased");
         valueBasedInternalType = enterSyntheticAnnotation("jdk.internal.ValueBased+Annotation");
+        requiresIdentityType = enterClass("jdk.internal.RequiresIdentity");
+        requiresIdentityInternalType = enterSyntheticAnnotation("jdk.internal.RequiresIdentity+Annotation");
         classDescType = enterClass("java.lang.constant.ClassDesc");
         enumDescType = enterClass("java.lang.Enum$EnumDesc");
         // For serialization lint checking

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java

@@ -665,6 +665,10 @@ public boolean isFinal() {
         return (tsym.flags() & FINAL) != 0;
     }
 
+    public boolean isValueBased() {
+        return tsym != null && (tsym.flags_field & VALUE_BASED) != 0;
+    }
+
     /**
      * Does this type contain occurrences of type t?
      */