Resolved review comments.

Author: tzezula

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/KnownTruffleTypes.java

@@ -106,6 +106,7 @@ public class KnownTruffleTypes extends AbstractKnownTruffleTypes {
     public final ResolvedJavaType UnexpectedResultException = lookupType("com.oracle.truffle.api.nodes.UnexpectedResultException");
     public final ResolvedJavaType SlowPathException = lookupType("com.oracle.truffle.api.nodes.SlowPathException");
     public final ResolvedJavaType ExplodeLoop = lookupType("com.oracle.truffle.api.nodes.ExplodeLoop");
+    public final ResolvedJavaType ExplodeLoop_LoopExplosionKind = lookupType("com.oracle.truffle.api.nodes.ExplodeLoop$LoopExplosionKind");
 
     // truffle.api.frame
     public final ResolvedJavaType VirtualFrame = lookupType("com.oracle.truffle.api.frame.VirtualFrame");

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/PartialEvaluator.java

@@ -210,26 +210,22 @@ public static PartialEvaluationMethodInfo computePartialEvaluationMethodInfo(Tru
         boolean specialization = declaredAnnotationValues.get(types.Specialization) != null;
         AnnotationValue explodeLoop = declaredAnnotationValues.get(types.ExplodeLoop);
 
-        return new PartialEvaluationMethodInfo(getLoopExplosionKind(explodeLoop),
+        return new PartialEvaluationMethodInfo(getLoopExplosionKind(explodeLoop, types),
                         getInlineKind(runtime, truffleBoundary, truffleCallBoundary, method, true, types),
                         getInlineKind(runtime, truffleBoundary, truffleCallBoundary, method, false, types),
                         method.canBeInlined(),
                         specialization);
     }
 
-    private static LoopExplosionKind getLoopExplosionKind(AnnotationValue value) {
+    private static LoopExplosionKind getLoopExplosionKind(AnnotationValue value, KnownTruffleTypes types) {
         if (value == null) {
             return LoopExplosionKind.NONE;
         }
-        String kind = value.get("kind", EnumElement.class).name;
-        return switch (kind) {
-            case "FULL_UNROLL" -> LoopExplosionKind.FULL_UNROLL;
-            case "FULL_UNROLL_UNTIL_RETURN" -> LoopExplosionKind.FULL_UNROLL_UNTIL_RETURN;
-            case "FULL_EXPLODE" -> LoopExplosionKind.FULL_EXPLODE;
-            case "FULL_EXPLODE_UNTIL_RETURN" -> LoopExplosionKind.FULL_EXPLODE_UNTIL_RETURN;
-            case "MERGE_EXPLODE" -> LoopExplosionKind.MERGE_EXPLODE;
-            default -> throw new InternalError(String.format("Unknown Truffle LoopExplosionKind %s", kind));
-        };
+        EnumElement enumElement = value.get("kind", EnumElement.class);
+        if (!types.ExplodeLoop_LoopExplosionKind.equals(enumElement.enumType)) {
+            throw new IllegalStateException("Incompatible ExplodeLoop change. ExplodeLoop.kind must be LoopExplosionKind.");
+        }
+        return Enum.valueOf(LoopExplosionKind.class, enumElement.name);
     }
 
     private static InlineKind getInlineKind(TruffleCompilerRuntime runtime, AnnotationValue truffleBoundary, AnnotationValue truffleCallBoundary,

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/TruffleElementCache.java

@@ -41,7 +41,7 @@ public abstract class TruffleElementCache<K, V> {
     /**
      * Value representing a null value in the cache.
      */
-    private final Object NULL_VALUE = new Object();
+    private static final Object NULL_VALUE = new Object();
 
     @SuppressWarnings("serial")
     protected TruffleElementCache(int maxSize) {

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/hotspot/HotSpotPartialEvaluator.java

@@ -123,6 +123,7 @@ public EconomicMap<ResolvedJavaMethod, EncodedGraph> getOrCreateEncodedGraphCach
             cache = graphCacheRef.get();
         } while (cache == null &&
                         !graphCacheRef.compareAndSet(null, cache = EconomicMap.wrapMap(new ConcurrentHashMap<>())));
+        assert cache != null;
         return cache;
     }
 

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedTruffleRuntime.java

@@ -189,6 +189,18 @@ private static boolean findInliningRootSupported() {
         }
 
         private static MethodHandle findGetAnnotation() {
+            /*
+             * In JDK versions prior to 25.1, ResolvedJavaType implemented AnnotatedElement, and the
+             * Graal compiler queried the Truffle runtime to retrieve annotation values.
+             *
+             * Starting with JDK 25.1, ResolvedJavaType no longer implements AnnotatedElement.
+             * Instead, the Graal compiler directly reads annotation values using the
+             * jdk.graal.compiler.annotation API.
+             *
+             * As a result, on JDK 25.1 and later, the Truffle runtime is never queried by the Graal
+             * compiler to obtain annotation values. For compatibility, getAnnotation is still
+             * supported when Truffle runs on GraalVM versions older than 25.1.
+             */
             if (AnnotatedElement.class.isAssignableFrom(ResolvedJavaType.class)) {
                 try {
                     Method method = AnnotatedElement.class.getDeclaredMethod("getAnnotation", Class.class);
@@ -488,6 +500,7 @@ private static UnmodifiableEconomicMap<String, Class<?>> initLookupTypes(Iterabl
                         InlineSupport.DoubleField.class,
                         InlineSupport.ReferenceField.class,
                         ExplodeLoop.class,
+                        ExplodeLoop.LoopExplosionKind.class,
                         Specialization.class,
                         TruffleCallBoundary.class,
         }) {