Refactor and extract logic for ModuleFields#setConstantInternal()

Author: eregon

src/main/java/org/truffleruby/collections/ConcurrentOperations.java

@@ -22,7 +22,7 @@ public abstract class ConcurrentOperations {
      * if they are no collisions in the bucket.
      * This method might execute the function multiple times, in contrast to computeIfAbsent().
      */
-    public static <V, K> V getOrCompute(Map<K, V> map, K key, Function<? super K, ? extends V> compute) {
+    public static <K, V> V getOrCompute(Map<K, V> map, K key, Function<? super K, ? extends V> compute) {
         V value = map.get(key);
         if (value != null) {
             return value;
@@ -33,4 +33,13 @@ public static <V, K> V getOrCompute(Map<K, V> map, K key, Function<? super K, ?
         }
     }
 
+    /**
+     * Similar to {@link Map#replace(Object, Object, Object)} except that the old value can also be
+     * null (missing). Returns true if the replace succeeded, or false if it should be retried
+     * because <code>map.get(key)</code> is no longer associated to <code>oldValue</code>.
+     */
+    public static <K, V> boolean replace(Map<K, V> map, K key, V oldValue, V newValue) {
+        return oldValue == null ? map.putIfAbsent(key, newValue) == null : map.replace(key, oldValue, newValue);
+    }
+
 }

src/main/java/org/truffleruby/core/module/ModuleFields.java

@@ -20,6 +20,7 @@
 
 import org.truffleruby.Layouts;
 import org.truffleruby.RubyLanguage;
+import org.truffleruby.collections.ConcurrentOperations;
 import org.truffleruby.RubyContext;
 import org.truffleruby.core.klass.ClassNodes;
 import org.truffleruby.core.method.MethodFilter;
@@ -333,18 +334,22 @@ private RubyConstant setConstantInternal(RubyContext context, Node currentNode,
 
         SharedObjects.propagate(context, rubyModuleObject, value);
 
-        while (true) {
-            final RubyConstant previous = constants.get(name);
-            final boolean isPrivate = previous != null && previous.isPrivate();
-            final boolean isDeprecated = previous != null && previous.isDeprecated();
-            final SourceSection sourceSection = currentNode != null ?  currentNode.getSourceSection() : null;
-            final RubyConstant newValue = new RubyConstant(rubyModuleObject, value, isPrivate, autoload, isDeprecated, sourceSection);
+        RubyConstant previous;
+        RubyConstant newConstant;
+        do {
+            previous = constants.get(name);
+            newConstant = newConstant(currentNode, value, autoload, previous);
+        } while (!ConcurrentOperations.replace(constants, name, previous, newConstant));
 
-            if (previous == null ? constants.putIfAbsent(name, newValue) == null : constants.replace(name, previous, newValue)) {
-                newConstantsVersion();
-                return previous;
-            }
-        }
+        newConstantsVersion();
+        return previous;
+    }
+
+    private RubyConstant newConstant(Node currentNode, Object value, boolean autoload, RubyConstant previous) {
+        final boolean isPrivate = previous != null && previous.isPrivate();
+        final boolean isDeprecated = previous != null && previous.isDeprecated();
+        final SourceSection sourceSection = currentNode != null ?  currentNode.getSourceSection() : null;
+        return new RubyConstant(rubyModuleObject, value, isPrivate, autoload, isDeprecated, sourceSection);
     }
 
     @TruffleBoundary