Small tidy up.

Author: aardvark179

doc/contributor/cext-values.md

@@ -51,11 +51,11 @@ to the stack, and when the call exits that entry is popped off again.
 
 We don't have a way to run markers when doing garbage collection, but
 we know we're keeping objects alive during the lifetime or a C call,
-and we can record when the structure is accessed (which should be
-required for the internal state of that structure to be mutated). To
-do this we keep a list of objects to be marked in a similar manner to
-the objects that should be kept alive, and when we exit the C call
-we'll call those markers.
+and we can record when the structure is accessed via DATA_PTR (which
+should be required for the internal state of that structure to be
+mutated). To do this we keep a list of objects to be marked in a
+similar manner to the objects that should be kept alive, and when we
+exit the C call we'll call those markers.
 
 ### Running mark functions
 

lib/truffle/truffle/cext.rb

@@ -1502,7 +1502,6 @@ def run_marker(obj)
     unless Truffle::Interop.null?(mark)
       create_mark_list(obj)
       data = Primitive.data_holder_get_data(data_holder)
-      # This call is done without pushing a new frame as the marking service manages frames itself.
       mark.call(data) unless Truffle::Interop.null?(data)
       set_mark_list_on_object(obj)
     end

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -34,6 +34,7 @@
 import org.truffleruby.cext.UnwrapNode.UnwrapCArrayNode;
 import org.truffleruby.core.MarkingService.ExtensionCallStack;
 import org.truffleruby.core.MarkingServiceNodes;
+import org.truffleruby.core.MarkingServiceNodes.RunMarkOnExitNode;;
 import org.truffleruby.core.array.ArrayToObjectArrayNode;
 import org.truffleruby.core.array.ArrayUtils;
 import org.truffleruby.core.array.RubyArray;
@@ -164,17 +165,14 @@ private static long getNativeStringCapacity(Pointer pointer) {
     @Primitive(name = "call_with_c_mutex_and_frame")
     public abstract static class CallWithCExtLockAndFrameNode extends PrimitiveArrayArgumentsNode {
 
-        @Child protected MarkingServiceNodes.RunMarkOnExitNode runMarksNode = MarkingServiceNodes.RunMarkOnExitNode
-                .create();
-
         @Specialization(limit = "getCacheLimit()")
         protected Object callWithCExtLockAndFrame(
                 VirtualFrame frame, Object receiver, RubyArray argsArray, Object specialVariables, Object block,
                 @CachedLibrary("receiver") InteropLibrary receivers,
                 @Cached ArrayToObjectArrayNode arrayToObjectArrayNode,
                 @Cached TranslateInteropExceptionNode translateInteropExceptionNode,
                 @Cached ConditionProfile ownedProfile,
-                @Cached MarkingServiceNodes.RunMarkOnExitNode runMarksNode) {
+                @Cached RunMarkOnExitNode runMarksNode) {
             final ExtensionCallStack extensionStack = getLanguage()
                     .getCurrentThread()
                     .getCurrentFiber().extensionCallStack;
@@ -219,17 +217,14 @@ protected int getCacheLimit() {
     @Primitive(name = "call_with_c_mutex_and_frame_and_unwrap")
     public abstract static class CallWithCExtLockAndFrameAndUnwrapNode extends PrimitiveArrayArgumentsNode {
 
-        @Child protected MarkingServiceNodes.RunMarkOnExitNode runMarksNode = MarkingServiceNodes.RunMarkOnExitNode
-                .create();
-
         @Specialization(limit = "getCacheLimit()")
         protected Object callWithCExtLockAndFrame(
                 VirtualFrame frame, Object receiver, RubyArray argsArray, Object specialVariables, Object block,
                 @CachedLibrary("receiver") InteropLibrary receivers,
                 @Cached ArrayToObjectArrayNode arrayToObjectArrayNode,
                 @Cached TranslateInteropExceptionNode translateInteropExceptionNode,
                 @Cached ConditionProfile ownedProfile,
-                @Cached MarkingServiceNodes.RunMarkOnExitNode runMarksNode,
+                @Cached RunMarkOnExitNode runMarksNode,
                 @Cached UnwrapNode unwrapNode) {
             final ExtensionCallStack extensionStack = getLanguage().getCurrentFiber().extensionCallStack;
             final boolean keywordsGiven = RubyArguments.getDescriptor(frame) instanceof KeywordArgumentsDescriptor;

src/main/java/org/truffleruby/core/MarkingServiceNodes.java

@@ -16,27 +16,24 @@
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.Specialization;
 
 public class MarkingServiceNodes {
 
-    public static class KeepAliveNode extends RubyBaseNode {
+    @GenerateUncached
+    public abstract static class KeepAliveNode extends RubyBaseNode {
 
-        public void execute(ValueWrapper object) {
+        public abstract void execute(ValueWrapper object);
+
+        @Specialization
+        protected void executeAddToList(ValueWrapper object) {
             addToList(getLanguage().getCurrentThread().getCurrentFiber().extensionCallStack, object);
         }
 
         protected void addToList(ExtensionCallStack stack, ValueWrapper object) {
             stack.keepObject(object);
         }
-
-        public static KeepAliveNode create() {
-            return new KeepAliveNode();
-        }
-
-        public static KeepAliveNode getUncached() {
-            return new KeepAliveNode();
-        }
     }
 
     public static class QueueForMarkOnExitNode extends RubyBaseNode {

src/main/java/org/truffleruby/core/array/ArrayToObjectArrayNode.java

@@ -36,7 +36,7 @@ public Object[] unsplat(Object[] arguments) {
     @Specialization(limit = "storageStrategyLimit()")
     protected Object[] toObjectArrayOther(RubyArray array,
             @Bind("array.getStore()") Object store,
-            @Cached("createIdentityProfile()") IntValueProfile sizeProfile,
+            @Cached IntValueProfile sizeProfile,
             @CachedLibrary("store") ArrayStoreLibrary stores) {
         final int size = sizeProfile.profile(array.size);
         return stores.boxedCopyOfRange(store, 0, size);

src/main/java/org/truffleruby/core/array/library/NativeArrayStorage.java

@@ -15,6 +15,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.TruffleSafepoint;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 import com.oracle.truffle.api.profiles.LoopConditionProfile;
 import org.truffleruby.cext.UnwrapNode;
@@ -296,6 +297,7 @@ public void getAdjacentObjects(Set<Object> reachable) {
         }
     }
 
+    @TruffleBoundary
     public void preserveMembers() {
         for (int i = 0; i < length; i++) {
             final Object value = UnwrapNativeNodeGen.getUncached().execute(readElement(i));

src/main/java/org/truffleruby/core/string/StringNodes.java

@@ -2572,7 +2572,8 @@ public abstract static class ToSymNode extends CoreMethodArrayArgumentsNode {
         @Specialization(
                 guards = {
                         "!isBrokenCodeRange(tstring, encoding, codeRangeNode)",
-                        "equalNode.execute(tstring, encoding, cachedTString, cachedEncoding)" },
+                        "equalNode.execute(tstring, encoding, cachedTString, cachedEncoding)",
+                        "preserveSymbol == cachedPreserveSymbol" },
                 limit = "getDefaultCacheLimit()")
         protected RubySymbol toSymCached(Object string, boolean preserveSymbol,
                 @Cached RubyStringLibrary strings,

src/main/java/org/truffleruby/core/symbol/SymbolTable.java

@@ -111,7 +111,9 @@ public RubySymbol getSymbol(AbstractTruffleString tstring, RubyEncoding original
         // do not keep the other TString alive unnecessarily.
         var savedSymbol = symbolMap.addInCacheIfAbsent(new TStringWithEncoding(cachedTString, symbolEncoding),
                 newSymbol);
-        preservedSymbolMap.put(key, savedSymbol);
+        if (preserveSymbol) {
+            preservedSymbolMap.put(key, savedSymbol);
+        }
         return savedSymbol;
     }
 

src/main/ruby/truffleruby/core/string.rb

@@ -151,11 +151,10 @@ def include?(needle)
     Primitive.as_boolean(Primitive.find_string(self, StringValue(needle), 0))
   end
 
-  def intern
+  def to_sym
     Primitive.string_to_symbol(self, false)
   end
-
-  alias_method :to_sym, :intern
+  alias_method :intern, :to_sym
 
   def lstrip
     str = Primitive.dup_as_string_instance(self)