Preserve symbols interned from C to match MRI semantics.

Author: aardvark179

lib/truffle/truffle/cext.rb

@@ -723,6 +723,10 @@ def rb_thread_alone
     Thread.list.count == 1 ? 1 : 0
   end
 
+  def rb_intern(str)
+    Primitive.string_to_symbol(str, true)
+  end
+
   def rb_int_positive_pow(a, b)
     a ** b
   end

src/main/c/cext/string.c

@@ -116,7 +116,7 @@ VALUE rb_str_inspect(VALUE string) {
 }
 
 ID rb_intern_str(VALUE string) {
-  return SYM2ID(RUBY_INVOKE(string, "intern"));
+  return SYM2ID(RUBY_CEXT_INVOKE("rb_intern", string));
 }
 
 VALUE rb_str_cat(VALUE string, const char *to_concat, long length) {

src/main/java/org/truffleruby/RubyLanguage.java

@@ -383,7 +383,12 @@ public RubySymbol getSymbol(String string) {
 
     @TruffleBoundary
     public RubySymbol getSymbol(AbstractTruffleString name, RubyEncoding encoding) {
-        return symbolTable.getSymbol(name, encoding);
+        return symbolTable.getSymbol(name, encoding, false);
+    }
+
+    @TruffleBoundary
+    public RubySymbol getSymbol(AbstractTruffleString name, RubyEncoding encoding, boolean preserveSymbol) {
+        return symbolTable.getSymbol(name, encoding, preserveSymbol);
     }
 
     public Assumption getTracingAssumption() {

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

@@ -2563,7 +2563,7 @@ public boolean isStringSubclass(RubyString string) {
         }
     }
 
-    @CoreMethod(names = { "to_sym", "intern" })
+    @Primitive(name = "string_to_symbol")
     @ImportStatic(StringGuards.class)
     public abstract static class ToSymNode extends CoreMethodArrayArgumentsNode {
 
@@ -2574,27 +2574,28 @@ public abstract static class ToSymNode extends CoreMethodArrayArgumentsNode {
                         "!isBrokenCodeRange(tstring, encoding, codeRangeNode)",
                         "equalNode.execute(tstring, encoding, cachedTString, cachedEncoding)" },
                 limit = "getDefaultCacheLimit()")
-        protected RubySymbol toSymCached(Object string,
+        protected RubySymbol toSymCached(Object string, boolean preserveSymbol,
                 @Cached RubyStringLibrary strings,
                 @Cached("asTruffleStringUncached(string)") TruffleString cachedTString,
                 @Cached("strings.getEncoding(string)") RubyEncoding cachedEncoding,
-                @Cached("getSymbol(cachedTString, cachedEncoding)") RubySymbol cachedSymbol,
+                @Cached("preserveSymbol") boolean cachedPreserveSymbol,
+                @Cached("getSymbol(cachedTString, cachedEncoding, cachedPreserveSymbol)") RubySymbol cachedSymbol,
                 @Cached StringHelperNodes.EqualSameEncodingNode equalNode,
                 @Bind("strings.getTString(string)") AbstractTruffleString tstring,
                 @Bind("strings.getEncoding(string)") RubyEncoding encoding) {
             return cachedSymbol;
         }
 
         @Specialization(guards = "!isBrokenCodeRange(tstring, encoding, codeRangeNode)", replaces = "toSymCached")
-        protected RubySymbol toSym(Object string,
+        protected RubySymbol toSym(Object string, boolean preserveSymbol,
                 @Cached RubyStringLibrary strings,
                 @Bind("strings.getTString(string)") AbstractTruffleString tstring,
                 @Bind("strings.getEncoding(string)") RubyEncoding encoding) {
-            return getSymbol(strings.getTString(string), strings.getEncoding(string));
+            return getSymbol(strings.getTString(string), strings.getEncoding(string), preserveSymbol);
         }
 
         @Specialization(guards = "isBrokenCodeRange(tstring, encoding, codeRangeNode)")
-        protected RubySymbol toSymBroken(Object string,
+        protected RubySymbol toSymBroken(Object string, boolean preserveSymbol,
                 @Cached RubyStringLibrary strings,
                 @Bind("strings.getTString(string)") AbstractTruffleString tstring,
                 @Bind("strings.getEncoding(string)") RubyEncoding encoding) {

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

@@ -10,6 +10,7 @@
 package org.truffleruby.core.symbol;
 
 import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
 
 import com.oracle.truffle.api.strings.AbstractTruffleString;
 import com.oracle.truffle.api.strings.TruffleString;
@@ -35,6 +36,10 @@ public class SymbolTable {
     // As long as the Symbol is referenced, the entry will stay in the symbolMap.
     private final WeakValueCache<TStringWithEncoding, RubySymbol> symbolMap = new WeakValueCache<>();
 
+    // A map of symbols that should be preserved and never collected,
+    // like those created by `rb_intern` and similar functions.
+    private final ConcurrentHashMap<TStringWithEncoding, RubySymbol> preservedSymbolMap = new ConcurrentHashMap<>();
+
     public SymbolTable(TStringCache tstringCache, CoreSymbols coreSymbols) {
         this.tstringCache = tstringCache;
         addCoreSymbols(coreSymbols);
@@ -75,7 +80,7 @@ public RubySymbol getSymbol(String string) {
             str = TStringUtils.utf8TString(string);
             encoding = Encodings.UTF_8;
         }
-        symbol = getSymbol(str, encoding);
+        symbol = getSymbol(str, encoding, false);
 
         // Add it to the direct java.lang.String to Symbol cache
         stringToSymbolCache.addInCacheIfAbsent(string, symbol);
@@ -84,19 +89,30 @@ public RubySymbol getSymbol(String string) {
     }
 
     @TruffleBoundary
-    public RubySymbol getSymbol(AbstractTruffleString tstring, RubyEncoding originalEncoding) {
+    public RubySymbol getSymbol(AbstractTruffleString tstring, RubyEncoding originalEncoding, boolean preserveSymbol) {
         var key = normalizeForLookup(tstring, originalEncoding);
-        final RubySymbol symbol = symbolMap.get(key);
+        RubySymbol symbol = preservedSymbolMap.get(key);
+        if (symbol != null) {
+            return symbol;
+        }
+        symbol = symbolMap.get(key);
         if (symbol != null) {
+            if (preserveSymbol) {
+                preservedSymbolMap.put(key, symbol);
+            }
             return symbol;
         }
 
+
         final RubyEncoding symbolEncoding = key.encoding;
         var cachedTString = tstringCache.getTString(key.tstring, symbolEncoding);
         final RubySymbol newSymbol = createSymbol(cachedTString, symbolEncoding);
         // Use a TStringWithEncoding with the cached TString in symbolMap, since the Symbol refers to it and so we
         // do not keep the other TString alive unnecessarily.
-        return symbolMap.addInCacheIfAbsent(new TStringWithEncoding(cachedTString, symbolEncoding), newSymbol);
+        var savedSymbol = symbolMap.addInCacheIfAbsent(new TStringWithEncoding(cachedTString, symbolEncoding),
+                newSymbol);
+        preservedSymbolMap.put(key, savedSymbol);
+        return savedSymbol;
     }
 
     @TruffleBoundary

src/main/java/org/truffleruby/language/RubyBaseNode.java

@@ -128,6 +128,10 @@ protected final RubySymbol getSymbol(AbstractTruffleString name, RubyEncoding en
         return getLanguage().getSymbol(name, encoding);
     }
 
+    protected final RubySymbol getSymbol(AbstractTruffleString name, RubyEncoding encoding, boolean preserveSymbol) {
+        return getLanguage().getSymbol(name, encoding, preserveSymbol);
+    }
+
     protected final CoreStrings coreStrings() {
         return getLanguage().coreStrings;
     }

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

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