Add storage type for some factories

Author: minborg

src/java.base/share/classes/java/lang/ComputedConstant.java

@@ -58,7 +58,7 @@
  *     </li>
  *     <li>Collections
  *         <ul>
- *             <li>{@linkplain ComputedConstant#of(int, IntFunction) ComputedConstant.of(int length, IntFunction&lt;? super V&gt; mappingProvider)}
+ *             <li>{@linkplain ComputedConstant#of(Class, int, IntFunction) ComputedConstant.of(Class&lt;? super V&gt, int length, IntFunction&lt;? super V&gt; mappingProvider)}
  *             providing a new List of ComputedConstant elements</li>
  *         </ul>
  *     </li>
@@ -428,7 +428,8 @@ static <V, R extends V> ComputedConstant<V> of(Class<R> returnType, MethodHandle
 
     /**
      * {@return a new unmodifiable List of {@link ComputedConstant } elements with the provided
-     * {@code size} and given pre-set {@code mappingProvider} to be used to compute element values}
+     *          {@code size} and given pre-set {@code mappingProvider} to be used to compute
+     *          element values}
      * <p>
      * The List and its elements are eligible for constant folding optimizations by the JVM.
      * <p>
@@ -448,11 +449,14 @@ static <V, R extends V> ComputedConstant<V> of(Class<R> returnType, MethodHandle
      *          ComputedConstant elements that has no valid identity.
      *
      * @param <V>             the type of the values
+     * @param storageType     a class literal representing an optional storage type of the bound values
      * @param size            the size of the List
      * @param mappingProvider to invoke when computing and binding element values
      */
-    static <V> List<ComputedConstant<V>> of(int size,
+    static <V> List<ComputedConstant<V>> of(Class<? super V> storageType,
+                                            int size,
                                             IntFunction<? extends V> mappingProvider) {
+        Objects.requireNonNull(storageType);
         if (size < 0) {
             throw new IllegalArgumentException();
         }

src/java.base/share/classes/java/lang/SettableConstant.java

@@ -226,7 +226,7 @@ static <V> SettableConstant<V> of(Class<? super V> storageType, V value) {
      *     class DemoList {
      *
      *         private static final List<SettableConstant<Long>> CONSTANTS =
-     *                 SettableConstant.of(32);
+     *                 SettableConstant.of(long.class, 32);
      *          static {
      *             // Compute values in the CONSTANTS list
      *          }
@@ -239,10 +239,12 @@ static <V> SettableConstant<V> of(Class<? super V> storageType, V value) {
      * @apiNote The list is free to return <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>
      *          ComputedConstant elements that has no valid identity.
      *
-     * @param <V>             the type of the values
-     * @param size            the size of the List
-         */
-    static <V> List<SettableConstant<V>> ofList(int size) {
+     * @param <V>         the type of the values
+     * @param storageType a class literal representing an optional storage type of the bound value
+     * @param size        the size of the List
+     */
+    static <V> List<SettableConstant<V>> of(Class<? super V> storageType, int size) {
+        Objects.requireNonNull(storageType);
         if (size < 0) {
             throw new IllegalArgumentException();
         }

src/java.base/share/classes/java/lang/snippet-files/ComputedConstantSnippets.java

@@ -227,7 +227,7 @@ class Fibonacci2 {
         private final List<ComputedConstant<Integer>> list;
 
         public Fibonacci2(int upperBound) {
-            list = ComputedConstant.of(upperBound, this::number);
+            list = ComputedConstant.of(int.class, upperBound, this::number);
         }
 
         public int number(int n) {
@@ -251,7 +251,7 @@ public static void main(String[] args) {
     class Fibonacci3 {
 
         private static final List<ComputedConstant<Integer>> LIST
-                = ComputedConstant.of(40, Fibonacci3::number);
+                = ComputedConstant.of(int.class, 40, Fibonacci3::number);
 
         public static int number(int n) {
             return (n < 2)

test/jdk/java/lang/ComputedConstant/SettableConstantTest.java

@@ -116,6 +116,24 @@ void predicates(Class<? super Integer> storageType) {
         assertTrue(constant.isBound());
     }
 
+    @ParameterizedTest
+    @MethodSource("storageTypes")
+    void computeIfUnbound(Class<? super Integer> storageType) {
+        SettableConstant<Integer> constant = SettableConstant.of(storageType);
+        Integer actual = constant.computeIfUnbound(() -> 2);
+        assertEquals(2, actual);
+        assertEquals(2, constant.get());
+    }
+
+    @ParameterizedTest
+    @MethodSource("storageTypes")
+    void computeIfUnboundBound(Class<? super Integer> storageType) {
+        SettableConstant<Integer> constant = SettableConstant.of(storageType, 1);
+        Integer actual = constant.computeIfUnbound(() -> 2);
+        assertEquals(1, actual);
+        assertEquals(1, constant.get());
+    }
+
     @ParameterizedTest
     @MethodSource("storageTypes")
     void setIfUnbound(Class<? super Integer> storageType) {