updated for JDK 27 third preview spec

Author: mbien

platform/o.n.jdk.fallback/src/org/netbeans/jdk/fallback/Bundle.properties

@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-OpenIDE-Module-Name=Simple JDK Fallbacks
+OpenIDE-Module-Name=Internal JDK Fallbacks
 OpenIDE-Module-Display-Category=Libraries
 OpenIDE-Module-Short-Description=Provides internal, non-permanent and possibly incomplete fallbacks for JDK APIs\
  which are useful for NetBeans but not covered by the minimal run requirements yet.

platform/o.n.jdk.fallback/src/org/netbeans/jdk/fallback/lang/NBLazyConstant.java

@@ -21,6 +21,7 @@
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
+import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.function.Supplier;
 import java.util.logging.Level;
@@ -29,6 +30,8 @@
 /**
  * Delegates to JDK's LazyConstant and provides a fallback implementation if not available.
  * 
+ * The fallback implementation simulates behavior of the JDk 27 LazyConstant spec.
+ * 
  * Internal API, may be removed when no longer needed.
  * 
  * @author mbien
@@ -75,9 +78,6 @@ private NBLazyConstant() {}
     @SuppressWarnings("unchecked")
     public static <T> Supplier<T> of(Supplier<? extends T> computingFunction) {
         Objects.requireNonNull(computingFunction);
-        if (computingFunction instanceof DoubleCheckedFallback<? extends T> lc) {
-            return (Supplier<T>) lc;
-        }
         if (lazyConstantFactory != null) {
             try {
                 return (Supplier<T>) lazyConstantFactory.invokeExact(computingFunction);
@@ -91,6 +91,8 @@ public static <T> Supplier<T> of(Supplier<? extends T> computingFunction) {
         }
     }
 
+    /// simmulates JDK 27 spec, 25 and 26 are more permissive
+    /// and may allow null or error recovery
     private static class DoubleCheckedFallback<T> implements Supplier<T> {
 
         private volatile T constant;
@@ -105,12 +107,19 @@ public T get() {
             T c = constant;
             if (c == null) {
                 synchronized (this) {
+                    if (factory == null) { // error state due to past supplier failure
+                        throw new NoSuchElementException("Unable to access the constant because an Exception was thrown at initial computation");
+                    }
                     c = constant;
                     if (c == null) {
-                        c = factory.get();
-                        Objects.requireNonNull(c);
+                        try {
+                            c = factory.get();
+                            Objects.requireNonNull(c);
+                        } catch (Throwable t) {
+                            factory = null;
+                            throw new NoSuchElementException(t);
+                        }
                         constant = c;
-                        factory = null;
                     }
                 }
             }

platform/o.n.jdk.fallback/test/unit/src/org/netbeans/jdk/fallback/lang/NBLazyConstantTest.java

@@ -18,7 +18,9 @@
  */
 package org.netbeans.jdk.fallback.lang;
 
+import java.util.NoSuchElementException;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 import org.junit.Test;
@@ -28,6 +30,9 @@
 
 public class NBLazyConstantTest {
 
+    // true if fallback or JDK 27 impl active
+    private static final boolean JDK27_SPEC = Runtime.version().feature() >= 27 || Runtime.version().feature() < 25;
+
     @Test
     public void testFactory() {
 
@@ -58,29 +63,60 @@ public void testConstant() {
     @Test
     public void testRequireNPEOnNullResult() {
 
-        // StableValue allows null, we use the LazyConstant spec
-        assumeTrue(Runtime.version().feature() != 25);
+        // StableValue allows null, we use the LazyConstant JDK 27 spec
+        // since its the least permissive
+        assumeTrue("jdk 25 impl supports null", Runtime.version().feature() != 25);
 
         AtomicReference<Object> value = new AtomicReference<>();
+        AtomicInteger calls = new AtomicInteger();
 
-        Supplier<Object> lazy = NBLazyConstant.of(() -> value.get());
+        Supplier<Object> lazy = NBLazyConstant.of(() -> {
+            calls.incrementAndGet();
+            return value.get();
+        });
         assertNotNull(lazy);
 
         try {
             lazy.get();
             fail();
-        } catch (NullPointerException good) {}
+        } catch (NoSuchElementException good) {
+            assertTrue(JDK27_SPEC);
+            assertEquals(NullPointerException.class, good.getCause().getClass());
+        } catch (NullPointerException good) {
+            assertFalse(JDK27_SPEC);
+        }
+        assertEquals(1, calls.get());
 
         try {
             lazy.get();
             fail();
-        } catch (NullPointerException stillGood) {}
+        } catch (NoSuchElementException stillGood) {
+            assertTrue(JDK27_SPEC);
+            // no cause anymore
+        } catch (NullPointerException stillGood) {
+            assertFalse(JDK27_SPEC);
+        }
+
+        // JDK 25-26 spec has retries, we don't test those since fallback mimics JDK 27
+        if (Runtime.version().feature() == 26) {
+            return;
+        }
+
+        assertEquals(1, calls.get());
 
         value.set("good");
 
-        // constant can be computed from now on
-        assertEquals("good", lazy.get());
-        assertEquals("good", lazy.get());
+        // JDK 27+ spec -> no recovery from error state
+        try {
+            lazy.get();
+            fail();
+        } catch (NoSuchElementException stillGood) {
+            assertTrue(JDK27_SPEC);
+        } catch (NullPointerException stillGood) {
+            assertFalse(JDK27_SPEC);
+        }
+        assertEquals(1, calls.get());
+
     }
 
     @Test
@@ -100,18 +136,41 @@ public void testExceptionDuringCompute() {
         try {
             lazy.get();
             fail();
-        } catch (RuntimeException good) {}
+        } catch (NoSuchElementException good) {
+            assertTrue(JDK27_SPEC);
+            assertEquals(RuntimeException.class, good.getCause().getClass());
+        } catch (RuntimeException good) {
+            assertFalse(JDK27_SPEC);
+            assertEquals(RuntimeException.class, good.getClass());
+        }
 
         try {
             lazy.get();
             fail();
-        } catch (RuntimeException stillGood) {}
+        } catch (NoSuchElementException good) {
+            assertTrue(JDK27_SPEC);
+            // no cause anymore
+        } catch (RuntimeException good) {
+            assertFalse(JDK27_SPEC);
+            assertEquals(RuntimeException.class, good.getClass());
+        }
 
         fail.set(false);
 
-        // constant can be computed from now on
-        assertEquals("good", lazy.get());
-        assertEquals("good", lazy.get());
+        // we don't test error recovery of 25 and 26
+        if (!JDK27_SPEC) {
+//            assertEquals("good", lazy.get());
+//            assertEquals("good", lazy.get());
+            return;
+        }
+
+        try {
+            lazy.get();
+            fail();
+        } catch (RuntimeException stillInFailureState) {
+            assertEquals(NoSuchElementException.class, stillInFailureState.getClass());
+        }
+        
     }
 
 }